dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 440
 441 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 457 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 458 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 459
 460 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 461 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 462 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 463
 464 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 465 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 466 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 467
 468 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 469 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 470 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 471
 472 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 473
 474 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 475 #include <dali/devel-api/adaptor-framework/image-loading.h>
 476
 477 #include <dali/public-api/events/mouse-button.h>
 478
 479 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 480 #include "web-view-signal-converter.h"
 481
 482 #include <dali/integration-api/debug.h>
 483
 484 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 485
 486 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 487
 488 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 489
 490
 491 #include <dali/devel-api/update/frame-callback-interface.h>
 492 #include <dali/devel-api/update/update-proxy.h>
 493
 494
 495 // add here SWIG version check
 496
 497 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 498 // disable Swig-dependent warnings
 499
 500 // 'identifier1' has C-linkage specified,
 501 // but returns UDT 'identifier2' which is incompatible with C
 502 #pragma warning(disable: 4190)
 503
 504 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 505 #pragma warning(disable: 4800)
 506
 507 // debug info too long etc etc
 508 #pragma warning(disable: 4786)
 509 #endif
 510
 511
 512 #include <stdexcept>
 513
 514
 515 #include <string>
 516
 517
 518 #include <vector>
 519 #include <algorithm>
 520 #include <stdexcept>
 521
 522
 523 #include <map>
 524 #include <algorithm>
 525 #include <stdexcept>
 526
 527
 528 #include <utility>
 529
 530
 531 typedef float floatp;
 532
 533 SWIGINTERN floatp *new_floatp(){
 534   return new float();
 535 }
 536 SWIGINTERN void delete_floatp(floatp *self){
 537   if (self) delete self;
 538 }
 539 SWIGINTERN void floatp_assign(floatp *self,float value){
 540   *self = value;
 541 }
 542 SWIGINTERN float floatp_value(floatp *self){
 543   return *self;
 544 }
 545 SWIGINTERN float *floatp_cast(floatp *self){
 546   return self;
 547 }
 548 SWIGINTERN floatp *floatp_frompointer(float *t){
 549   return (floatp *) t;
 550 }
 551
 552 typedef int intp;
 553
 554 SWIGINTERN intp *new_intp(){
 555   return new int();
 556 }
 557 SWIGINTERN void delete_intp(intp *self){
 558   if (self) delete self;
 559 }
 560 SWIGINTERN void intp_assign(intp *self,int value){
 561   *self = value;
 562 }
 563 SWIGINTERN int intp_value(intp *self){
 564   return *self;
 565 }
 566 SWIGINTERN int *intp_cast(intp *self){
 567   return self;
 568 }
 569 SWIGINTERN intp *intp_frompointer(int *t){
 570   return (intp *) t;
 571 }
 572
 573 typedef double doublep;
 574
 575 SWIGINTERN doublep *new_doublep(){
 576   return new double();
 577 }
 578 SWIGINTERN void delete_doublep(doublep *self){
 579   if (self) delete self;
 580 }
 581 SWIGINTERN void doublep_assign(doublep *self,double value){
 582   *self = value;
 583 }
 584 SWIGINTERN double doublep_value(doublep *self){
 585   return *self;
 586 }
 587 SWIGINTERN double *doublep_cast(doublep *self){
 588   return self;
 589 }
 590 SWIGINTERN doublep *doublep_frompointer(double *t){
 591   return (doublep *) t;
 592 }
 593
 594 typedef unsigned int uintp;
 595
 596 SWIGINTERN uintp *new_uintp(){
 597   return new unsigned int();
 598 }
 599 SWIGINTERN void delete_uintp(uintp *self){
 600   if (self) delete self;
 601 }
 602 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 603   *self = value;
 604 }
 605 SWIGINTERN unsigned int uintp_value(uintp *self){
 606   return *self;
 607 }
 608 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 609   return self;
 610 }
 611 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 612   return (uintp *) t;
 613 }
 614
 615 typedef unsigned short ushortp;
 616
 617 SWIGINTERN ushortp *new_ushortp(){
 618   return new unsigned short();
 619 }
 620 SWIGINTERN void delete_ushortp(ushortp *self){
 621   if (self) delete self;
 622 }
 623 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 624   *self = value;
 625 }
 626 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 627   return *self;
 628 }
 629 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 630   return self;
 631 }
 632 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 633   return (ushortp *) t;
 634 }
 635
 636 unsigned int int_to_uint(int x) {
 637    return (unsigned int) x;
 638 }
 639
 640
 641 using namespace Dali;
 642 using namespace Dali::Toolkit;
 643
 644 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 645 {
 646   bool result = false;
 647   try
 648   {
 649     // C++ code. DALi uses Handle <-> Body design pattern.
 650     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 651     // Handles in DALi can be converted into a boolean type
 652     // to check if the handle has a valid body attached to it.
 653     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 654     if( *self )
 655     {
 656       result = true;
 657     }
 658     else
 659     {
 660       result = false;
 661     }
 662   }
 663   catch (std::out_of_range& e)
 664   {
 665     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 666     return 0;
 667   }
 668   catch (std::exception& e)
 669   {
 670     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 671     return 0;
 672   }
 673   catch (DaliException e)
 674   {
 675     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 676     return 0;
 677   }
 678   catch (...)
 679   {
 680     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 681     return 0;
 682   }
 683   return result;
 684 }
 685
 686 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 687 {
 688   bool result = false;
 689   try
 690   {
 691     // C++ code. Check if two handles reference the same implemtion
 692     if( *self == rhs)
 693     {
 694       result = true;
 695     }
 696     else
 697     {
 698       result = false;
 699     }
 700   }
 701   catch (std::out_of_range& e)
 702   {
 703     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 704     return 0;
 705   }
 706   catch (std::exception& e)
 707   {
 708     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 709     return 0;
 710   }
 711   catch (DaliException e)
 712   {
 713     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 714     return 0;
 715   }
 716   catch (...)
 717   {
 718     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 719     return 0;
 720   }
 721   return result;
 722 }
 723
 724
 725 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 726      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 727    }
 728 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 729      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 730    }
 731 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 732         std::vector< Dali::TouchPoint >* pv = 0;
 733         if (capacity >= 0) {
 734           pv = new std::vector< Dali::TouchPoint >();
 735           pv->reserve(capacity);
 736        } else {
 737           throw std::out_of_range("capacity");
 738        }
 739        return pv;
 740       }
 741 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 742         if (index>=0 && index<(int)self->size())
 743           return (*self)[index];
 744         else
 745           throw std::out_of_range("index");
 746       }
 747 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 748         if (index>=0 && index<(int)self->size())
 749           return (*self)[index];
 750         else
 751           throw std::out_of_range("index");
 752       }
 753 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 754         if (index>=0 && index<(int)self->size())
 755           (*self)[index] = val;
 756         else
 757           throw std::out_of_range("index");
 758       }
 759 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 760         self->insert(self->end(), values.begin(), values.end());
 761       }
 762 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 763         if (index < 0)
 764           throw std::out_of_range("index");
 765         if (count < 0)
 766           throw std::out_of_range("count");
 767         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 768           throw std::invalid_argument("invalid range");
 769         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 770       }
 771 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 772         if (index>=0 && index<(int)self->size()+1)
 773           self->insert(self->begin()+index, x);
 774         else
 775           throw std::out_of_range("index");
 776       }
 777 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 778         if (index>=0 && index<(int)self->size()+1)
 779           self->insert(self->begin()+index, values.begin(), values.end());
 780         else
 781           throw std::out_of_range("index");
 782       }
 783 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 784         if (index>=0 && index<(int)self->size())
 785           self->erase(self->begin() + index);
 786         else
 787           throw std::out_of_range("index");
 788       }
 789 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 790         if (index < 0)
 791           throw std::out_of_range("index");
 792         if (count < 0)
 793           throw std::out_of_range("count");
 794         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 795           throw std::invalid_argument("invalid range");
 796         self->erase(self->begin()+index, self->begin()+index+count);
 797       }
 798 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 799         if (count < 0)
 800           throw std::out_of_range("count");
 801         return new std::vector< Dali::TouchPoint >(count, value);
 802       }
 803 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 804         std::reverse(self->begin(), self->end());
 805       }
 806 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 807         if (index < 0)
 808           throw std::out_of_range("index");
 809         if (count < 0)
 810           throw std::out_of_range("count");
 811         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 812           throw std::invalid_argument("invalid range");
 813         std::reverse(self->begin()+index, self->begin()+index+count);
 814       }
 815 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 816         if (index < 0)
 817           throw std::out_of_range("index");
 818         if (index+values.size() > self->size())
 819           throw std::out_of_range("index");
 820         std::copy(values.begin(), values.end(), self->begin()+index);
 821       }
 822 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 823          return self->Empty();
 824       }
 825 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 826         return self->GetConnectionCount();
 827       }
 828 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 829           self->Connect( func );
 830       }
 831 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 832           self->Disconnect( func );
 833       }
 834 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 835           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 836 /*@SWIG@*/ self->Emit( arg );
 837       }
 838 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 839          return self->Empty();
 840       }
 841 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 842         return self->GetConnectionCount();
 843       }
 844 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 845           self->Connect( func );
 846       }
 847 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 848           self->Disconnect( func );
 849       }
 850 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 851           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 852 /*@SWIG@*/ self->Emit( arg );
 853       }
 854 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 855          return self->Empty();
 856       }
 857 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 858         return self->GetConnectionCount();
 859       }
 860 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 861           self->Connect( func );
 862       }
 863 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 864           self->Disconnect( func );
 865       }
 866 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 867           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 868 /*@SWIG@*/ self->Emit( arg );
 869       }
 870 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 871          return self->Empty();
 872       }
 873 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 874         return self->GetConnectionCount();
 875       }
 876 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 877           self->Connect( func );
 878       }
 879 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 880           self->Disconnect( func );
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 883           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 884 /*@SWIG@*/ self->Emit( arg );
 885       }
 886 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 887          return self->Empty();
 888       }
 889 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 890         return self->GetConnectionCount();
 891       }
 892 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 893         self->Connect( func );
 894       }
 895 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 896         self->Disconnect( func );
 897       }
 898 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 899         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 900 /*@SWIG@*/ self->Emit( arg1, arg2 );
 901       }
 902 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 903          return self->Empty();
 904       }
 905 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 906         return self->GetConnectionCount();
 907       }
 908 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 909         self->Connect( func );
 910       }
 911 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 912         self->Disconnect( func );
 913       }
 914 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 915         return self->Emit( arg1, arg2 );
 916       }
 917 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 918          return self->Empty();
 919       }
 920 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 921         return self->GetConnectionCount();
 922       }
 923 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 924         self->Connect( func );
 925       }
 926 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 927         self->Disconnect( func );
 928       }
 929 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 930         return self->Emit( arg1, arg2 );
 931       }
 932 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 933          return self->Empty();
 934       }
 935 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 936         return self->GetConnectionCount();
 937       }
 938 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 939         self->Connect( func );
 940       }
 941 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 942         self->Disconnect( func );
 943       }
 944 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 945         return self->Emit( arg1, arg2 );
 946       }
 947 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 948          return self->Empty();
 949       }
 950 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 951         return self->GetConnectionCount();
 952       }
 953 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 954           self->Connect( func );
 955       }
 956 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 957           self->Disconnect( func );
 958       }
 959 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 960           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 961 /*@SWIG@*/ self->Emit( arg );
 962       }
 963 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 964          return self->Empty();
 965       }
 966 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 967         return self->GetConnectionCount();
 968       }
 969 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 970           self->Connect( func );
 971       }
 972 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 973           self->Disconnect( func );
 974       }
 975 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 976           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 977 /*@SWIG@*/ self->Emit( arg );
 978       }
 979 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 980          return self->Empty();
 981       }
 982 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 983         return self->GetConnectionCount();
 984       }
 985 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 986           self->Connect( func );
 987       }
 988 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 989           self->Disconnect( func );
 990       }
 991 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 992           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 993 /*@SWIG@*/ self->Emit( arg );
 994       }
 995 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 996          return self->Empty();
 997       }
 998 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 999         return self->GetConnectionCount();
1000       }
1001 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1002           self->Connect( func );
1003       }
1004 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1005           self->Disconnect( func );
1006       }
1007 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
1008           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1009 /*@SWIG@*/ self->Emit( arg );
1010       }
1011 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1012          return self->Empty();
1013       }
1014 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1015         return self->GetConnectionCount();
1016       }
1017 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1018         self->Connect( func );
1019       }
1020 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1021         self->Disconnect( func );
1022       }
1023 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1024         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1025 /*@SWIG@*/ self->Emit( arg1, arg2 );
1026       }
1027 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1028          return self->Empty();
1029       }
1030 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1031         return self->GetConnectionCount();
1032       }
1033 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1034         self->Connect( func );
1035       }
1036 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1037         self->Disconnect( func );
1038       }
1039 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1040         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1041 /*@SWIG@*/ self->Emit( arg1, arg2 );
1042       }
1043 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1044          return self->Empty();
1045       }
1046 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1047         return self->GetConnectionCount();
1048       }
1049 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1050         self->Connect( func );
1051       }
1052 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1053         self->Disconnect( func );
1054       }
1055 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1056         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1057 /*@SWIG@*/ self->Emit( arg1, arg2 );
1058       }
1059 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1060          return self->Empty();
1061       }
1062 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1063         return self->GetConnectionCount();
1064       }
1065 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1066           return self->Connect( func );
1067       }
1068 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1069           self->Disconnect( func );
1070       }
1071 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1072           self->Emit( arg1, arg3 );
1073       }
1074 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1075          return self->Empty();
1076       }
1077 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1078         return self->GetConnectionCount();
1079       }
1080 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1081           return self->Connect( func );
1082       }
1083 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1084           self->Disconnect( func );
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1087           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1088 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1089       }
1090
1091 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1092          return self->Empty();
1093       }
1094 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1095         return self->GetConnectionCount();
1096       }
1097 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1098           self->Connect( func );
1099       }
1100 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1101           self->Disconnect( func );
1102       }
1103 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1104           return self->Emit();
1105       }
1106
1107 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1108         std::vector< unsigned int >* pv = 0;
1109         if (capacity >= 0) {
1110           pv = new std::vector< unsigned int >();
1111           pv->reserve(capacity);
1112        } else {
1113           throw std::out_of_range("capacity");
1114        }
1115        return pv;
1116       }
1117 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1118         if (index>=0 && index<(int)self->size())
1119           return (*self)[index];
1120         else
1121           throw std::out_of_range("index");
1122       }
1123 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1124         if (index>=0 && index<(int)self->size())
1125           return (*self)[index];
1126         else
1127           throw std::out_of_range("index");
1128       }
1129 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1130         if (index>=0 && index<(int)self->size())
1131           (*self)[index] = val;
1132         else
1133           throw std::out_of_range("index");
1134       }
1135 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1136         self->insert(self->end(), values.begin(), values.end());
1137       }
1138 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1139         if (index < 0)
1140           throw std::out_of_range("index");
1141         if (count < 0)
1142           throw std::out_of_range("count");
1143         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1144           throw std::invalid_argument("invalid range");
1145         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1148         if (index>=0 && index<(int)self->size()+1)
1149           self->insert(self->begin()+index, x);
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1154         if (index>=0 && index<(int)self->size()+1)
1155           self->insert(self->begin()+index, values.begin(), values.end());
1156         else
1157           throw std::out_of_range("index");
1158       }
1159 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1160         if (index>=0 && index<(int)self->size())
1161           self->erase(self->begin() + index);
1162         else
1163           throw std::out_of_range("index");
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1166         if (index < 0)
1167           throw std::out_of_range("index");
1168         if (count < 0)
1169           throw std::out_of_range("count");
1170         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1171           throw std::invalid_argument("invalid range");
1172         self->erase(self->begin()+index, self->begin()+index+count);
1173       }
1174 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1175         if (count < 0)
1176           throw std::out_of_range("count");
1177         return new std::vector< unsigned int >(count, value);
1178       }
1179 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1180         std::reverse(self->begin(), self->end());
1181       }
1182 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1183         if (index < 0)
1184           throw std::out_of_range("index");
1185         if (count < 0)
1186           throw std::out_of_range("count");
1187         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1188           throw std::invalid_argument("invalid range");
1189         std::reverse(self->begin()+index, self->begin()+index+count);
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1192         if (index < 0)
1193           throw std::out_of_range("index");
1194         if (index+values.size() > self->size())
1195           throw std::out_of_range("index");
1196         std::copy(values.begin(), values.end(), self->begin()+index);
1197       }
1198 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1199         return std::find(self->begin(), self->end(), value) != self->end();
1200       }
1201 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1202         int index = -1;
1203         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1204         if (it != self->end())
1205           index = (int)(it - self->begin());
1206         return index;
1207       }
1208 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1209         int index = -1;
1210         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1211         if (rit != self->rend())
1212           index = (int)(self->rend() - 1 - rit);
1213         return index;
1214       }
1215 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1216         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1217         if (it != self->end()) {
1218           self->erase(it);
1219           return true;
1220         }
1221         return false;
1222       }
1223 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1224         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1225         if (capacity >= 0) {
1226           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1227           pv->reserve(capacity);
1228        } else {
1229           throw std::out_of_range("capacity");
1230        }
1231        return pv;
1232       }
1233 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1234         if (index>=0 && index<(int)self->size())
1235           return (*self)[index];
1236         else
1237           throw std::out_of_range("index");
1238       }
1239 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1240         if (index>=0 && index<(int)self->size())
1241           return (*self)[index];
1242         else
1243           throw std::out_of_range("index");
1244       }
1245 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1246         if (index>=0 && index<(int)self->size())
1247           (*self)[index] = val;
1248         else
1249           throw std::out_of_range("index");
1250       }
1251 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1252         self->insert(self->end(), values.begin(), values.end());
1253       }
1254 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1255         if (index < 0)
1256           throw std::out_of_range("index");
1257         if (count < 0)
1258           throw std::out_of_range("count");
1259         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1260           throw std::invalid_argument("invalid range");
1261         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1262       }
1263 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1264         if (index>=0 && index<(int)self->size()+1)
1265           self->insert(self->begin()+index, x);
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1270         if (index>=0 && index<(int)self->size()+1)
1271           self->insert(self->begin()+index, values.begin(), values.end());
1272         else
1273           throw std::out_of_range("index");
1274       }
1275 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1276         if (index>=0 && index<(int)self->size())
1277           self->erase(self->begin() + index);
1278         else
1279           throw std::out_of_range("index");
1280       }
1281 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1282         if (index < 0)
1283           throw std::out_of_range("index");
1284         if (count < 0)
1285           throw std::out_of_range("count");
1286         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1287           throw std::invalid_argument("invalid range");
1288         self->erase(self->begin()+index, self->begin()+index+count);
1289       }
1290 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1291         if (count < 0)
1292           throw std::out_of_range("count");
1293         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1294       }
1295 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1296         std::reverse(self->begin(), self->end());
1297       }
1298 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1299         if (index < 0)
1300           throw std::out_of_range("index");
1301         if (count < 0)
1302           throw std::out_of_range("count");
1303         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1304           throw std::invalid_argument("invalid range");
1305         std::reverse(self->begin()+index, self->begin()+index+count);
1306       }
1307 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1308         if (index < 0)
1309           throw std::out_of_range("index");
1310         if (index+values.size() > self->size())
1311           throw std::out_of_range("index");
1312         std::copy(values.begin(), values.end(), self->begin()+index);
1313       }
1314 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1315         std::vector< Dali::Actor >* pv = 0;
1316         if (capacity >= 0) {
1317           pv = new std::vector< Dali::Actor >();
1318           pv->reserve(capacity);
1319        } else {
1320           throw std::out_of_range("capacity");
1321        }
1322        return pv;
1323       }
1324 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1325         if (index>=0 && index<(int)self->size())
1326           return (*self)[index];
1327         else
1328           throw std::out_of_range("index");
1329       }
1330 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1331         if (index>=0 && index<(int)self->size())
1332           return (*self)[index];
1333         else
1334           throw std::out_of_range("index");
1335       }
1336 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1337         if (index>=0 && index<(int)self->size())
1338           (*self)[index] = val;
1339         else
1340           throw std::out_of_range("index");
1341       }
1342 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1343         self->insert(self->end(), values.begin(), values.end());
1344       }
1345 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1346         if (index < 0)
1347           throw std::out_of_range("index");
1348         if (count < 0)
1349           throw std::out_of_range("count");
1350         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1351           throw std::invalid_argument("invalid range");
1352         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1355         if (index>=0 && index<(int)self->size()+1)
1356           self->insert(self->begin()+index, x);
1357         else
1358           throw std::out_of_range("index");
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1361         if (index>=0 && index<(int)self->size()+1)
1362           self->insert(self->begin()+index, values.begin(), values.end());
1363         else
1364           throw std::out_of_range("index");
1365       }
1366 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1367         if (index>=0 && index<(int)self->size())
1368           self->erase(self->begin() + index);
1369         else
1370           throw std::out_of_range("index");
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1373         if (index < 0)
1374           throw std::out_of_range("index");
1375         if (count < 0)
1376           throw std::out_of_range("count");
1377         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1378           throw std::invalid_argument("invalid range");
1379         self->erase(self->begin()+index, self->begin()+index+count);
1380       }
1381 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1382         if (count < 0)
1383           throw std::out_of_range("count");
1384         return new std::vector< Dali::Actor >(count, value);
1385       }
1386 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1387         std::reverse(self->begin(), self->end());
1388       }
1389 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1390         if (index < 0)
1391           throw std::out_of_range("index");
1392         if (count < 0)
1393           throw std::out_of_range("count");
1394         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1395           throw std::invalid_argument("invalid range");
1396         std::reverse(self->begin()+index, self->begin()+index+count);
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1399         if (index < 0)
1400           throw std::out_of_range("index");
1401         if (index+values.size() > self->size())
1402           throw std::out_of_range("index");
1403         std::copy(values.begin(), values.end(), self->begin()+index);
1404       }
1405 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1406          return self->Empty();
1407       }
1408 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1409         return self->GetConnectionCount();
1410       }
1411 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1412           self->Connect( func );
1413       }
1414 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1415           self->Disconnect( func );
1416       }
1417 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1418           return self->Emit( arg );
1419       }
1420 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1421          return self->Empty();
1422       }
1423 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1424         return self->GetConnectionCount();
1425       }
1426 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1427         self->Connect( func );
1428       }
1429 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1430         self->Disconnect( func );
1431       }
1432 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1433         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1434 /*@SWIG@*/ self->Emit( arg1, arg2 );
1435       }
1436 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1437          return self->Empty();
1438       }
1439 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1440         return self->GetConnectionCount();
1441       }
1442 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1443         self->Connect( func );
1444       }
1445 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1446         self->Disconnect( func );
1447       }
1448 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1449         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1450 /*@SWIG@*/ self->Emit( arg1, arg2 );
1451       }
1452 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1453          return self->Empty();
1454       }
1455 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1456         return self->GetConnectionCount();
1457       }
1458 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1459         self->Connect( func );
1460       }
1461 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1462         self->Disconnect( func );
1463       }
1464 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1465         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1466 /*@SWIG@*/ self->Emit( arg1, arg2 );
1467       }
1468 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1469          return self->Empty();
1470       }
1471 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1472         return self->GetConnectionCount();
1473       }
1474 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1475         self->Connect( func );
1476       }
1477 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1478         self->Disconnect( func );
1479       }
1480 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1481         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1482 /*@SWIG@*/ self->Emit( arg1, arg2 );
1483       }
1484 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1485          return self->Empty();
1486       }
1487 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1488         return self->GetConnectionCount();
1489       }
1490 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1491           self->Connect( func );
1492       }
1493 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1494           self->Disconnect( func );
1495       }
1496 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1497           return self->Emit( arg );
1498       }
1499 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1500          return self->Empty();
1501       }
1502 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1503         return self->GetConnectionCount();
1504       }
1505 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1506           self->Connect( func );
1507       }
1508 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1509           self->Disconnect( func );
1510       }
1511 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1512           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1513 /*@SWIG@*/ self->Emit( arg );
1514       }
1515 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1516          return self->Empty();
1517       }
1518 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1519         return self->GetConnectionCount();
1520       }
1521 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1522           return self->Connect( func );
1523       }
1524 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1525           self->Disconnect( func );
1526       }
1527 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1528           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1529 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1530       }
1531 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1532          return self->Empty();
1533       }
1534 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1535         return self->GetConnectionCount();
1536       }
1537 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1538           self->Connect( func );
1539       }
1540 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1541           self->Disconnect( func );
1542       }
1543 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1544           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1545 /*@SWIG@*/ self->Emit( arg );
1546       }
1547 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1548          return self->Empty();
1549       }
1550 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1551         return self->GetConnectionCount();
1552       }
1553 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1554           return self->Connect( func );
1555       }
1556 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1557           self->Disconnect( func );
1558       }
1559 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1560           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1561 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1562       }
1563 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1564          return self->Empty();
1565       }
1566 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1567         return self->GetConnectionCount();
1568       }
1569 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1570           self->Connect( func );
1571       }
1572 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1573           self->Disconnect( func );
1574       }
1575 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1576           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1577 /*@SWIG@*/ self->Emit( arg );
1578       }
1579 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1580          return self->Empty();
1581       }
1582 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1583         return self->GetConnectionCount();
1584       }
1585 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1586           self->Connect( func );
1587       }
1588 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1589           self->Disconnect( func );
1590       }
1591 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1592           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1593 /*@SWIG@*/ self->Emit( arg );
1594       }
1595
1596
1597 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1598          return self->Empty();
1599       }
1600 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1601         return self->GetConnectionCount();
1602       }
1603 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1604         self->Connect( func );
1605       }
1606 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1607         self->Disconnect( func );
1608       }
1609 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1610         return self->Emit( arg1, arg2 );
1611       }
1612 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1613          return self->Empty();
1614       }
1615 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1616         return self->GetConnectionCount();
1617       }
1618 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1619           self->Connect( func );
1620       }
1621 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1622           self->Disconnect( func );
1623       }
1624 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1625           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1626 /*@SWIG@*/ self->Emit( arg );
1627       }
1628 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1629          return self->Empty();
1630       }
1631 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1632         return self->GetConnectionCount();
1633       }
1634 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1635           self->Connect( func );
1636       }
1637 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1638           self->Disconnect( func );
1639       }
1640 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1641           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1642 /*@SWIG@*/ self->Emit( arg );
1643       }
1644 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1645          return self->Empty();
1646       }
1647 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1648         return self->GetConnectionCount();
1649       }
1650 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1651         self->Connect( func );
1652       }
1653 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1654         self->Disconnect( func );
1655       }
1656 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1657         return self->Emit( arg1, arg2 );
1658       }
1659 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1660          return self->Empty();
1661       }
1662 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1663         return self->GetConnectionCount();
1664       }
1665 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1666         self->Connect( func );
1667       }
1668 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1669         self->Disconnect( func );
1670       }
1671 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1672         return self->Emit( arg1, arg2 );
1673       }
1674
1675 /* ---------------------------------------------------
1676  * C++ director class methods
1677  * --------------------------------------------------- */
1678
1679 #include "dali_wrap.h"
1680
1681 /*
1682  *  Widget director
1683  */
1684 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1685   swig_init_callbacks();
1686 }
1687
1688 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1689 }
1690
1691 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1692   char * jcontentInfo = 0 ;
1693   void * jwindow  ;
1694
1695   if (!swig_callbackOnCreate) {
1696     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1697     return;
1698   } else {
1699     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1700     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1701     swig_callbackOnCreate(jcontentInfo, jwindow);
1702   }
1703 }
1704
1705 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1706   char * jcontentInfo = 0 ;
1707   int jtype  ;
1708
1709   if (!swig_callbackOnTerminate) {
1710     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1711     return;
1712   } else {
1713     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1714     jtype = (int)type;
1715     swig_callbackOnTerminate(jcontentInfo, jtype);
1716   }
1717 }
1718
1719 void SwigDirector_WidgetImpl::OnPause() {
1720   if (!swig_callbackOnPause) {
1721     Dali::Internal::Adaptor::Widget::OnPause();
1722     return;
1723   } else {
1724     swig_callbackOnPause();
1725   }
1726 }
1727
1728 void SwigDirector_WidgetImpl::OnResume() {
1729   if (!swig_callbackOnResume) {
1730     Dali::Internal::Adaptor::Widget::OnResume();
1731     return;
1732   } else {
1733     swig_callbackOnResume();
1734   }
1735 }
1736
1737 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1738   void * jwindow  ;
1739
1740   if (!swig_callbackOnResize) {
1741     Dali::Internal::Adaptor::Widget::OnResize(window);
1742     return;
1743   } else {
1744     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1745     swig_callbackOnResize(jwindow);
1746   }
1747 }
1748
1749 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1750   char * jcontentInfo = 0 ;
1751   int jforce  ;
1752
1753   if (!swig_callbackOnUpdate) {
1754     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1755     return;
1756   } else {
1757     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1758     jforce = force;
1759     swig_callbackOnUpdate(jcontentInfo, jforce);
1760   }
1761 }
1762
1763 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1764   void * jslotObserver = 0 ;
1765   void * jcallback = 0 ;
1766
1767   if (!swig_callbackSignalConnected) {
1768     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1769     return;
1770   } else {
1771     jslotObserver = (void *) slotObserver;
1772     jcallback = (void *) callback;
1773     swig_callbackSignalConnected(jslotObserver, jcallback);
1774   }
1775 }
1776
1777 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1778   void * jslotObserver = 0 ;
1779   void * jcallback = 0 ;
1780
1781   if (!swig_callbackSignalDisconnected) {
1782     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1783     return;
1784   } else {
1785     jslotObserver = (void *) slotObserver;
1786     jcallback = (void *) callback;
1787     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1788   }
1789 }
1790
1791 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1792
1793   swig_callbackOnCreate = callbackOnCreate;
1794   swig_callbackOnTerminate = callbackOnTerminate;
1795   swig_callbackOnPause = callbackOnPause;
1796   swig_callbackOnResume = callbackOnResume;
1797   swig_callbackOnResize = callbackOnResize;
1798   swig_callbackOnUpdate = callbackOnUpdate;
1799   swig_callbackSignalConnected = callbackSignalConnected;
1800   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1801 }
1802
1803 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1804   swig_callbackOnCreate = 0;
1805   swig_callbackOnTerminate = 0;
1806   swig_callbackOnPause = 0;
1807   swig_callbackOnResume = 0;
1808   swig_callbackOnResize = 0;
1809   swig_callbackOnUpdate = 0;
1810   swig_callbackSignalConnected = 0;
1811   swig_callbackSignalDisconnected = 0;
1812 }
1813
1814
1815 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1816   swig_init_callbacks();
1817 }
1818
1819 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1820
1821 }
1822
1823
1824 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1825   int jdepth  ;
1826
1827   if (!swig_callbackOnSceneConnection) {
1828     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1829     return;
1830   } else {
1831     jdepth = depth;
1832     swig_callbackOnSceneConnection(jdepth);
1833   }
1834 }
1835
1836 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1837   if (!swig_callbackOnSceneDisconnection) {
1838     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1839     return;
1840   } else {
1841     swig_callbackOnSceneDisconnection();
1842   }
1843 }
1844
1845 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1846   void * jchild = 0 ;
1847
1848   if (!swig_callbackOnChildAdd) {
1849     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1850     return;
1851   } else {
1852     jchild = (Dali::Actor *) &child;
1853     swig_callbackOnChildAdd(jchild);
1854   }
1855 }
1856
1857 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1858   void * jchild = 0 ;
1859
1860   if (!swig_callbackOnChildRemove) {
1861     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1862     return;
1863   } else {
1864     jchild = (Dali::Actor *) &child;
1865     swig_callbackOnChildRemove(jchild);
1866   }
1867 }
1868
1869 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1870   int jindex  ;
1871   void * jpropertyValue  ;
1872
1873   if (!swig_callbackOnPropertySet) {
1874     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1875     return;
1876   } else {
1877     jindex = index;
1878     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1879     swig_callbackOnPropertySet(jindex, jpropertyValue);
1880   }
1881 }
1882
1883 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1884   void * jtargetSize = 0 ;
1885
1886   if (!swig_callbackOnSizeSet) {
1887     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1888     return;
1889   } else {
1890     jtargetSize = (Dali::Vector3 *) &targetSize;
1891     swig_callbackOnSizeSet(jtargetSize);
1892   }
1893 }
1894
1895 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1896   void * janimation = 0 ;
1897   void * jtargetSize = 0 ;
1898
1899   if (!swig_callbackOnSizeAnimation) {
1900     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1901     return;
1902   } else {
1903     janimation = (Dali::Animation *) &animation;
1904     jtargetSize = (Dali::Vector3 *) &targetSize;
1905     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1906   }
1907 }
1908
1909 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1910   bool c_result = SwigValueInit< bool >() ;
1911   unsigned int jresult = 0 ;
1912   void * jarg0 = 0 ;
1913
1914   if (!swig_callbackOnTouchEvent) {
1915     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1916   } else {
1917     jarg0 = (Dali::TouchEvent *) &event;
1918     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1919     c_result = jresult ? true : false;
1920   }
1921   return c_result;
1922 }
1923
1924 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1925   bool c_result = SwigValueInit< bool >() ;
1926   unsigned int jresult = 0 ;
1927   void * jarg0 = 0 ;
1928
1929   if (!swig_callbackOnHoverEvent) {
1930     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1931   } else {
1932     jarg0 = (Dali::HoverEvent *) &event;
1933     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1934     c_result = jresult ? true : false;
1935   }
1936   return c_result;
1937 }
1938
1939 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1940   bool c_result = SwigValueInit< bool >() ;
1941   unsigned int jresult = 0 ;
1942   void * jarg0 = 0 ;
1943
1944   if (!swig_callbackOnKeyEvent) {
1945     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1946   } else {
1947     jarg0 = (Dali::KeyEvent *) &event;
1948     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1949     c_result = jresult ? true : false;
1950   }
1951   return c_result;
1952 }
1953
1954 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1955   bool c_result = SwigValueInit< bool >() ;
1956   unsigned int jresult = 0 ;
1957   void * jarg0 = 0 ;
1958
1959   if (!swig_callbackOnWheelEvent) {
1960     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1961   } else {
1962     jarg0 = (Dali::WheelEvent *) &event;
1963     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1964     c_result = jresult ? true : false;
1965   }
1966   return c_result;
1967 }
1968
1969 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1970   void * jsize = 0 ;
1971   void * jcontainer = 0 ;
1972
1973   if (!swig_callbackOnRelayout) {
1974     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1975     return;
1976   } else {
1977     jsize = (Dali::Vector2 *) &size;
1978     jcontainer = (Dali::RelayoutContainer *) &container;
1979     swig_callbackOnRelayout(jsize, jcontainer);
1980   }
1981 }
1982
1983 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1984   int jpolicy  ;
1985   int jdimension  ;
1986
1987   if (!swig_callbackOnSetResizePolicy) {
1988     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1989     return;
1990   } else {
1991     jpolicy = (int)policy;
1992     jdimension = (int)dimension;
1993     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1994   }
1995 }
1996
1997 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1998   Dali::Vector3 c_result ;
1999   void * jresult = 0 ;
2000
2001   if (!swig_callbackGetNaturalSize) {
2002     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2003   } else {
2004     jresult = (void *) swig_callbackGetNaturalSize();
2005     if (!jresult) {
2006       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2007       return c_result;
2008     }
2009     c_result = *(Dali::Vector3 *)jresult;
2010   }
2011   return c_result;
2012 }
2013
2014 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2015   float c_result = SwigValueInit< float >() ;
2016   float jresult = 0 ;
2017   void * jchild = 0 ;
2018   int jdimension  ;
2019
2020   if (!swig_callbackCalculateChildSize) {
2021     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2022   } else {
2023     jchild = (Dali::Actor *) &child;
2024     jdimension = (int)dimension;
2025     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2026     c_result = (float)jresult;
2027   }
2028   return c_result;
2029 }
2030
2031 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2032   float c_result = SwigValueInit< float >() ;
2033   float jresult = 0 ;
2034   float jwidth  ;
2035
2036   if (!swig_callbackGetHeightForWidth) {
2037     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2038   } else {
2039     jwidth = width;
2040     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2041     c_result = (float)jresult;
2042   }
2043   return c_result;
2044 }
2045
2046 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2047   float c_result = SwigValueInit< float >() ;
2048   float jresult = 0 ;
2049   float jheight  ;
2050
2051   if (!swig_callbackGetWidthForHeight) {
2052     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2053   } else {
2054     jheight = height;
2055     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2056     c_result = (float)jresult;
2057   }
2058   return c_result;
2059 }
2060
2061 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2062   bool c_result = SwigValueInit< bool >() ;
2063   unsigned int jresult = 0 ;
2064   int jdimension  ;
2065
2066   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2067     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2068   } else {
2069     jdimension = (int)dimension;
2070     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2071     c_result = jresult ? true : false;
2072   }
2073   return c_result;
2074 }
2075
2076 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2077   int jdimension  ;
2078
2079   if (!swig_callbackOnCalculateRelayoutSize) {
2080     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2081     return;
2082   } else {
2083     jdimension = (int)dimension;
2084     swig_callbackOnCalculateRelayoutSize(jdimension);
2085   }
2086 }
2087
2088 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2089   float jsize  ;
2090   int jdimension  ;
2091
2092   if (!swig_callbackOnLayoutNegotiated) {
2093     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2094     return;
2095   } else {
2096     jsize = size;
2097     jdimension = (int)dimension;
2098     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2099   }
2100 }
2101
2102 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2103   return Dali::CustomActorImpl::GetExtension();
2104 }
2105
2106 void SwigDirector_ViewImpl::OnInitialize() {
2107   if (!swig_callbackOnInitialize) {
2108     Dali::Toolkit::Internal::Control::OnInitialize();
2109     return;
2110   } else {
2111     swig_callbackOnInitialize();
2112   }
2113 }
2114
2115 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2116   void * jstyleManager  ;
2117   int jchange  ;
2118
2119   if (!swig_callbackOnStyleChange) {
2120     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2121     return;
2122   } else {
2123     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2124     jchange = (int)change;
2125     swig_callbackOnStyleChange(jstyleManager, jchange);
2126   }
2127 }
2128
2129 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2130   bool c_result = SwigValueInit< bool >() ;
2131   unsigned int jresult = 0 ;
2132
2133   if (!swig_callbackOnAccessibilityActivated) {
2134     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2135   } else {
2136     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2137     c_result = jresult ? true : false;
2138   }
2139   return c_result;
2140 }
2141
2142 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2143   bool c_result = SwigValueInit< bool >() ;
2144   unsigned int jresult = 0 ;
2145   void * jgesture  ;
2146
2147   if (!swig_callbackOnAccessibilityPan) {
2148     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2149   } else {
2150     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2151     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2152     c_result = jresult ? true : false;
2153   }
2154   return c_result;
2155 }
2156
2157 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2158   bool c_result = SwigValueInit< bool >() ;
2159   unsigned int jresult = 0 ;
2160   void * jtouchEvent = 0 ;
2161
2162   if (!swig_callbackOnAccessibilityTouch) {
2163     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2164   } else {
2165     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2166     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2167     c_result = jresult ? true : false;
2168   }
2169   return c_result;
2170 }
2171
2172 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2173   bool c_result = SwigValueInit< bool >() ;
2174   unsigned int jresult = 0 ;
2175   unsigned int jisIncrease  ;
2176
2177   if (!swig_callbackOnAccessibilityValueChange) {
2178     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2179   } else {
2180     jisIncrease = isIncrease;
2181     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2182     c_result = jresult ? true : false;
2183   }
2184   return c_result;
2185 }
2186
2187 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2188   bool c_result = SwigValueInit< bool >() ;
2189   unsigned int jresult = 0 ;
2190
2191   if (!swig_callbackOnAccessibilityZoom) {
2192     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2193   } else {
2194     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2195     c_result = jresult ? true : false;
2196   }
2197   return c_result;
2198 }
2199
2200 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2201   if (!swig_callbackOnKeyInputFocusGained) {
2202     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2203     return;
2204   } else {
2205     swig_callbackOnKeyInputFocusGained();
2206   }
2207 }
2208
2209 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2210   if (!swig_callbackOnKeyInputFocusLost) {
2211     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2212     return;
2213   } else {
2214     swig_callbackOnKeyInputFocusLost();
2215   }
2216 }
2217
2218 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2219   Dali::Actor c_result ;
2220   void * jresult = 0 ;
2221   void * jcurrentFocusedActor  ;
2222   int jdirection  ;
2223   unsigned int jloopEnabled  ;
2224
2225   if (!swig_callbackGetNextKeyboardFocusableActor) {
2226     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2227   } else {
2228     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2229     jdirection = (int)direction;
2230     jloopEnabled = loopEnabled;
2231     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2232     if (!jresult) {
2233       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2234       return c_result;
2235     }
2236     c_result = *(Dali::Actor *)jresult;
2237   }
2238   return c_result;
2239 }
2240
2241 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2242   void * jcommitedFocusableActor  ;
2243
2244   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2245     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2246     return;
2247   } else {
2248     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2249     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2250   }
2251 }
2252
2253 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2254   bool c_result = SwigValueInit< bool >() ;
2255   unsigned int jresult = 0 ;
2256
2257   if (!swig_callbackOnKeyboardEnter) {
2258     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2259   } else {
2260     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2261     c_result = jresult ? true : false;
2262   }
2263   return c_result;
2264 }
2265
2266 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2267   void * jpinch = 0 ;
2268
2269   if (!swig_callbackOnPinch) {
2270     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2271     return;
2272   } else {
2273     jpinch = (Dali::PinchGesture *) &pinch;
2274     swig_callbackOnPinch(jpinch);
2275   }
2276 }
2277
2278 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2279   void * jpan = 0 ;
2280
2281   if (!swig_callbackOnPan) {
2282     Dali::Toolkit::Internal::Control::OnPan(pan);
2283     return;
2284   } else {
2285     jpan = (Dali::PanGesture *) &pan;
2286     swig_callbackOnPan(jpan);
2287   }
2288 }
2289
2290 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2291   void * jtap = 0 ;
2292
2293   if (!swig_callbackOnTap) {
2294     Dali::Toolkit::Internal::Control::OnTap(tap);
2295     return;
2296   } else {
2297     jtap = (Dali::TapGesture *) &tap;
2298     swig_callbackOnTap(jtap);
2299   }
2300 }
2301
2302 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2303   void * jlongPress = 0 ;
2304
2305   if (!swig_callbackOnLongPress) {
2306     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2307     return;
2308   } else {
2309     jlongPress = (Dali::LongPressGesture *) &longPress;
2310     swig_callbackOnLongPress(jlongPress);
2311   }
2312 }
2313
2314 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2315   void * jslotObserver = 0 ;
2316   void * jcallback = 0 ;
2317
2318   if (!swig_callbackSignalConnected) {
2319     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2320     return;
2321   } else {
2322     jslotObserver = (void *) slotObserver;
2323     jcallback = (void *) callback;
2324     swig_callbackSignalConnected(jslotObserver, jcallback);
2325   }
2326 }
2327
2328 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2329   void * jslotObserver = 0 ;
2330   void * jcallback = 0 ;
2331
2332   if (!swig_callbackSignalDisconnected) {
2333     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2334     return;
2335   } else {
2336     jslotObserver = (void *) slotObserver;
2337     jcallback = (void *) callback;
2338     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2339   }
2340 }
2341
2342 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2343   return Dali::Toolkit::Internal::Control::GetControlExtension();
2344 }
2345
2346 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2347   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2348   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2349   swig_callbackOnChildAdd = callbackOnChildAdd;
2350   swig_callbackOnChildRemove = callbackOnChildRemove;
2351   swig_callbackOnPropertySet = callbackOnPropertySet;
2352   swig_callbackOnSizeSet = callbackOnSizeSet;
2353   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2354   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2355   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2356   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2357   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2358   swig_callbackOnRelayout = callbackOnRelayout;
2359   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2360   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2361   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2362   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2363   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2364   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2365   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2366   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2367   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2368   swig_callbackOnInitialize = callbackOnInitialize;
2369   swig_callbackOnStyleChange = callbackOnStyleChange;
2370   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2371   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2372   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2373   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2374   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2375   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2376   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2377   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2378   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2379   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2380   swig_callbackOnPinch = callbackOnPinch;
2381   swig_callbackOnPan = callbackOnPan;
2382   swig_callbackOnTap = callbackOnTap;
2383   swig_callbackOnLongPress = callbackOnLongPress;
2384   swig_callbackSignalConnected = callbackSignalConnected;
2385   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2386 }
2387
2388 void SwigDirector_ViewImpl::swig_init_callbacks() {
2389   swig_callbackOnSceneConnection = 0;
2390   swig_callbackOnSceneDisconnection = 0;
2391   swig_callbackOnChildAdd = 0;
2392   swig_callbackOnChildRemove = 0;
2393   swig_callbackOnPropertySet = 0;
2394   swig_callbackOnSizeSet = 0;
2395   swig_callbackOnSizeAnimation = 0;
2396   swig_callbackOnTouchEvent = 0;
2397   swig_callbackOnHoverEvent = 0;
2398   swig_callbackOnKeyEvent = 0;
2399   swig_callbackOnWheelEvent = 0;
2400   swig_callbackOnRelayout = 0;
2401   swig_callbackOnSetResizePolicy = 0;
2402   swig_callbackGetNaturalSize = 0;
2403   swig_callbackCalculateChildSize = 0;
2404   swig_callbackGetHeightForWidth = 0;
2405   swig_callbackGetWidthForHeight = 0;
2406   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2407   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2408   swig_callbackOnCalculateRelayoutSize = 0;
2409   swig_callbackOnLayoutNegotiated = 0;
2410   swig_callbackOnInitialize = 0;
2411   swig_callbackOnStyleChange = 0;
2412   swig_callbackOnAccessibilityActivated = 0;
2413   swig_callbackOnAccessibilityPan = 0;
2414   swig_callbackOnAccessibilityTouch = 0;
2415   swig_callbackOnAccessibilityValueChange = 0;
2416   swig_callbackOnAccessibilityZoom = 0;
2417   swig_callbackOnKeyInputFocusGained = 0;
2418   swig_callbackOnKeyInputFocusLost = 0;
2419   swig_callbackGetNextKeyboardFocusableActor = 0;
2420   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2421   swig_callbackOnKeyboardEnter = 0;
2422   swig_callbackOnPinch = 0;
2423   swig_callbackOnPan = 0;
2424   swig_callbackOnTap = 0;
2425   swig_callbackOnLongPress = 0;
2426   swig_callbackSignalConnected = 0;
2427   swig_callbackSignalDisconnected = 0;
2428 }
2429
2430 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2431   swig_init_callbacks();
2432 }
2433
2434 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2435
2436 }
2437
2438
2439 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2440   unsigned int c_result = SwigValueInit< unsigned int >() ;
2441   unsigned int jresult = 0 ;
2442
2443   if (!swig_callbackGetNumberOfItems) {
2444     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2445   } else {
2446     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2447     c_result = (unsigned int)jresult;
2448   }
2449   return c_result;
2450 }
2451
2452 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2453   Dali::Actor c_result ;
2454   void * jresult = 0 ;
2455   unsigned int jitemId  ;
2456
2457   if (!swig_callbackNewItem) {
2458     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2459   } else {
2460     jitemId = itemId;
2461     jresult = (void *) swig_callbackNewItem(jitemId);
2462     if (!jresult) {
2463       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2464       return c_result;
2465     }
2466     c_result = *(Dali::Actor *)jresult;
2467   }
2468   return c_result;
2469 }
2470
2471 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2472   unsigned int jitemId  ;
2473   void * jactor  ;
2474
2475   if (!swig_callbackItemReleased) {
2476     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2477     return;
2478   } else {
2479     jitemId = itemId;
2480     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2481     swig_callbackItemReleased(jitemId, jactor);
2482   }
2483 }
2484
2485 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2486   return Dali::Toolkit::ItemFactory::GetExtension();
2487 }
2488
2489 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2490   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2491   swig_callbackNewItem = callbackNewItem;
2492   swig_callbackItemReleased = callbackItemReleased;
2493 }
2494
2495 void SwigDirector_ItemFactory::swig_init_callbacks() {
2496   swig_callbackGetNumberOfItems = 0;
2497   swig_callbackNewItem = 0;
2498   swig_callbackItemReleased = 0;
2499 }
2500
2501 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2502   swig_init_callbacks();
2503 }
2504
2505 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2506
2507 }
2508
2509
2510 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2511   Dali::Actor c_result ;
2512   void * jresult = 0 ;
2513   void * jcurrent  ;
2514   void * jproposed  ;
2515   int jdirection  ;
2516
2517   if (!swig_callbackGetNextFocusableActor) {
2518     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2519   } else {
2520     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2521     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2522     jdirection = (int)direction;
2523     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2524     if (!jresult) {
2525       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs! ", __FILE__, __LINE__);
2526       return c_result;
2527     }
2528     c_result = *(Dali::Actor *)jresult;
2529   }
2530   return c_result;
2531 }
2532
2533 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2534   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2535 }
2536
2537 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2538   swig_callbackGetNextFocusableActor = 0;
2539 }
2540
2541 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2542   swig_callbackOnUpdate = 0;
2543 }
2544
2545 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2546
2547 }
2548
2549 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2550   swig_callbackOnUpdate = callbackUpdate;
2551 }
2552
2553
2554 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2555   void * jcurrent  ;
2556
2557   if (!swig_callbackOnUpdate) {
2558     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2559   } else {
2560     Dali::UpdateProxy* proxy = &updateProxy;
2561     jcurrent = (void *)proxy;
2562     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2563     if (!jcurrent) {
2564       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2565       return;
2566     }
2567   }
2568   return;
2569 }
2570
2571
2572 #ifdef __cplusplus
2573 extern "C" {
2574 #endif
2575
2576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2577   void * jresult ;
2578   floatp *result = 0 ;
2579
2580   {
2581     try {
2582       result = (floatp *)new_floatp();
2583     } catch (std::out_of_range& e) {
2584       {
2585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2586       };
2587     } catch (std::exception& e) {
2588       {
2589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2590       };
2591     } catch (DaliException e) {
2592       {
2593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2594       };
2595     } catch (...) {
2596       {
2597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2598       };
2599     }
2600   }
2601   jresult = (void *)result;
2602   return jresult;
2603 }
2604
2605
2606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2607   floatp *arg1 = (floatp *) 0 ;
2608
2609   arg1 = (floatp *)jarg1;
2610   {
2611     try {
2612       delete_floatp(arg1);
2613     } catch (std::out_of_range& e) {
2614       {
2615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2616       };
2617     } catch (std::exception& e) {
2618       {
2619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2620       };
2621     } catch (Dali::DaliException e) {
2622       {
2623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2624       };
2625     } catch (...) {
2626       {
2627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2628       };
2629     }
2630   }
2631
2632 }
2633
2634
2635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2636   floatp *arg1 = (floatp *) 0 ;
2637   float arg2 ;
2638
2639   arg1 = (floatp *)jarg1;
2640   arg2 = (float)jarg2;
2641   {
2642     try {
2643       floatp_assign(arg1,arg2);
2644     } catch (std::out_of_range& e) {
2645       {
2646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2647       };
2648     } catch (std::exception& e) {
2649       {
2650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2651       };
2652     } catch (Dali::DaliException e) {
2653       {
2654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2655       };
2656     } catch (...) {
2657       {
2658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2659       };
2660     }
2661   }
2662
2663 }
2664
2665
2666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2667   float jresult ;
2668   floatp *arg1 = (floatp *) 0 ;
2669   float result;
2670
2671   arg1 = (floatp *)jarg1;
2672   {
2673     try {
2674       result = (float)floatp_value(arg1);
2675     } catch (std::out_of_range& e) {
2676       {
2677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2678       };
2679     } catch (std::exception& e) {
2680       {
2681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2682       };
2683     } catch (DaliException e) {
2684       {
2685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2686       };
2687     } catch (...) {
2688       {
2689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2690       };
2691     }
2692   }
2693   jresult = result;
2694   return jresult;
2695 }
2696
2697
2698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2699   void * jresult ;
2700   floatp *arg1 = (floatp *) 0 ;
2701   float *result = 0 ;
2702
2703   arg1 = (floatp *)jarg1;
2704   {
2705     try {
2706       result = (float *)floatp_cast(arg1);
2707     } catch (std::out_of_range& e) {
2708       {
2709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2710       };
2711     } catch (std::exception& e) {
2712       {
2713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2714       };
2715     } catch (Dali::DaliException e) {
2716       {
2717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2718       };
2719     } catch (...) {
2720       {
2721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2722       };
2723     }
2724   }
2725
2726   jresult = (void *)result;
2727   return jresult;
2728 }
2729
2730
2731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2732   void * jresult ;
2733   float *arg1 = (float *) 0 ;
2734   floatp *result = 0 ;
2735
2736   arg1 = (float *)jarg1;
2737   {
2738     try {
2739       result = (floatp *)floatp_frompointer(arg1);
2740     } catch (std::out_of_range& e) {
2741       {
2742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2743       };
2744     } catch (std::exception& e) {
2745       {
2746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2747       };
2748     } catch (Dali::DaliException e) {
2749       {
2750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2751       };
2752     } catch (...) {
2753       {
2754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2755       };
2756     }
2757   }
2758
2759   jresult = (void *)result;
2760   return jresult;
2761 }
2762
2763
2764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2765   void * jresult ;
2766   intp *result = 0 ;
2767
2768   {
2769     try {
2770       result = (intp *)new_intp();
2771     } catch (std::out_of_range& e) {
2772       {
2773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2774       };
2775     } catch (std::exception& e) {
2776       {
2777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2778       };
2779     } catch (Dali::DaliException e) {
2780       {
2781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2782       };
2783     } catch (...) {
2784       {
2785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2786       };
2787     }
2788   }
2789
2790   jresult = (void *)result;
2791   return jresult;
2792 }
2793
2794
2795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2796   intp *arg1 = (intp *) 0 ;
2797
2798   arg1 = (intp *)jarg1;
2799   {
2800     try {
2801       delete_intp(arg1);
2802     } catch (std::out_of_range& e) {
2803       {
2804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2805       };
2806     } catch (std::exception& e) {
2807       {
2808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2809       };
2810     } catch (Dali::DaliException e) {
2811       {
2812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2813       };
2814     } catch (...) {
2815       {
2816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2817       };
2818     }
2819   }
2820
2821 }
2822
2823
2824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2825   intp *arg1 = (intp *) 0 ;
2826   int arg2 ;
2827
2828   arg1 = (intp *)jarg1;
2829   arg2 = (int)jarg2;
2830   {
2831     try {
2832       intp_assign(arg1,arg2);
2833     } catch (std::out_of_range& e) {
2834       {
2835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2836       };
2837     } catch (std::exception& e) {
2838       {
2839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2840       };
2841     } catch (Dali::DaliException e) {
2842       {
2843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2844       };
2845     } catch (...) {
2846       {
2847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2848       };
2849     }
2850   }
2851
2852 }
2853
2854
2855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2856   int jresult ;
2857   intp *arg1 = (intp *) 0 ;
2858   int result;
2859
2860   arg1 = (intp *)jarg1;
2861   {
2862     try {
2863       result = (int)intp_value(arg1);
2864     } catch (std::out_of_range& e) {
2865       {
2866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2867       };
2868     } catch (std::exception& e) {
2869       {
2870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2871       };
2872     } catch (Dali::DaliException e) {
2873       {
2874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2875       };
2876     } catch (...) {
2877       {
2878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2879       };
2880     }
2881   }
2882
2883   jresult = result;
2884   return jresult;
2885 }
2886
2887
2888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2889   void * jresult ;
2890   intp *arg1 = (intp *) 0 ;
2891   int *result = 0 ;
2892
2893   arg1 = (intp *)jarg1;
2894   {
2895     try {
2896       result = (int *)intp_cast(arg1);
2897     } catch (std::out_of_range& e) {
2898       {
2899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2900       };
2901     } catch (std::exception& e) {
2902       {
2903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2904       };
2905     } catch (Dali::DaliException e) {
2906       {
2907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2908       };
2909     } catch (...) {
2910       {
2911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2912       };
2913     }
2914   }
2915
2916   jresult = (void *)result;
2917   return jresult;
2918 }
2919
2920
2921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2922   void * jresult ;
2923   int *arg1 = (int *) 0 ;
2924   intp *result = 0 ;
2925
2926   arg1 = (int *)jarg1;
2927   {
2928     try {
2929       result = (intp *)intp_frompointer(arg1);
2930     } catch (std::out_of_range& e) {
2931       {
2932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2933       };
2934     } catch (std::exception& e) {
2935       {
2936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2937       };
2938     } catch (Dali::DaliException e) {
2939       {
2940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2941       };
2942     } catch (...) {
2943       {
2944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2945       };
2946     }
2947   }
2948
2949   jresult = (void *)result;
2950   return jresult;
2951 }
2952
2953
2954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2955   void * jresult ;
2956   doublep *result = 0 ;
2957
2958   {
2959     try {
2960       result = (doublep *)new_doublep();
2961     } catch (std::out_of_range& e) {
2962       {
2963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2964       };
2965     } catch (std::exception& e) {
2966       {
2967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2968       };
2969     } catch (Dali::DaliException e) {
2970       {
2971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2972       };
2973     } catch (...) {
2974       {
2975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2976       };
2977     }
2978   }
2979
2980   jresult = (void *)result;
2981   return jresult;
2982 }
2983
2984
2985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2986   doublep *arg1 = (doublep *) 0 ;
2987
2988   arg1 = (doublep *)jarg1;
2989   {
2990     try {
2991       delete_doublep(arg1);
2992     } catch (std::out_of_range& e) {
2993       {
2994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2995       };
2996     } catch (std::exception& e) {
2997       {
2998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2999       };
3000     } catch (Dali::DaliException e) {
3001       {
3002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3003       };
3004     } catch (...) {
3005       {
3006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3007       };
3008     }
3009   }
3010
3011 }
3012
3013
3014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3015   doublep *arg1 = (doublep *) 0 ;
3016   double arg2 ;
3017
3018   arg1 = (doublep *)jarg1;
3019   arg2 = (double)jarg2;
3020   {
3021     try {
3022       doublep_assign(arg1,arg2);
3023     } catch (std::out_of_range& e) {
3024       {
3025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3026       };
3027     } catch (std::exception& e) {
3028       {
3029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3030       };
3031     } catch (Dali::DaliException e) {
3032       {
3033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3034       };
3035     } catch (...) {
3036       {
3037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3038       };
3039     }
3040   }
3041
3042 }
3043
3044
3045 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3046   double jresult ;
3047   doublep *arg1 = (doublep *) 0 ;
3048   double result;
3049
3050   arg1 = (doublep *)jarg1;
3051   {
3052     try {
3053       result = (double)doublep_value(arg1);
3054     } catch (std::out_of_range& e) {
3055       {
3056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3057       };
3058     } catch (std::exception& e) {
3059       {
3060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3061       };
3062     } catch (Dali::DaliException e) {
3063       {
3064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3065       };
3066     } catch (...) {
3067       {
3068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3069       };
3070     }
3071   }
3072
3073   jresult = result;
3074   return jresult;
3075 }
3076
3077
3078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3079   void * jresult ;
3080   doublep *arg1 = (doublep *) 0 ;
3081   double *result = 0 ;
3082
3083   arg1 = (doublep *)jarg1;
3084   {
3085     try {
3086       result = (double *)doublep_cast(arg1);
3087     } catch (std::out_of_range& e) {
3088       {
3089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3090       };
3091     } catch (std::exception& e) {
3092       {
3093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3094       };
3095     } catch (Dali::DaliException e) {
3096       {
3097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3098       };
3099     } catch (...) {
3100       {
3101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3102       };
3103     }
3104   }
3105
3106   jresult = (void *)result;
3107   return jresult;
3108 }
3109
3110
3111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3112   void * jresult ;
3113   double *arg1 = (double *) 0 ;
3114   doublep *result = 0 ;
3115
3116   arg1 = (double *)jarg1;
3117   {
3118     try {
3119       result = (doublep *)doublep_frompointer(arg1);
3120     } catch (std::out_of_range& e) {
3121       {
3122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3123       };
3124     } catch (std::exception& e) {
3125       {
3126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3127       };
3128     } catch (Dali::DaliException e) {
3129       {
3130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3131       };
3132     } catch (...) {
3133       {
3134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3135       };
3136     }
3137   }
3138
3139   jresult = (void *)result;
3140   return jresult;
3141 }
3142
3143
3144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3145   void * jresult ;
3146   uintp *result = 0 ;
3147
3148   {
3149     try {
3150       result = (uintp *)new_uintp();
3151     } catch (std::out_of_range& e) {
3152       {
3153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3154       };
3155     } catch (std::exception& e) {
3156       {
3157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3158       };
3159     } catch (Dali::DaliException e) {
3160       {
3161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3162       };
3163     } catch (...) {
3164       {
3165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3166       };
3167     }
3168   }
3169
3170   jresult = (void *)result;
3171   return jresult;
3172 }
3173
3174
3175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3176   uintp *arg1 = (uintp *) 0 ;
3177
3178   arg1 = (uintp *)jarg1;
3179   {
3180     try {
3181       delete_uintp(arg1);
3182     } catch (std::out_of_range& e) {
3183       {
3184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3185       };
3186     } catch (std::exception& e) {
3187       {
3188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3189       };
3190     } catch (Dali::DaliException e) {
3191       {
3192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3193       };
3194     } catch (...) {
3195       {
3196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3197       };
3198     }
3199   }
3200
3201 }
3202
3203
3204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3205   uintp *arg1 = (uintp *) 0 ;
3206   unsigned int arg2 ;
3207
3208   arg1 = (uintp *)jarg1;
3209   arg2 = (unsigned int)jarg2;
3210   {
3211     try {
3212       uintp_assign(arg1,arg2);
3213     } catch (std::out_of_range& e) {
3214       {
3215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3216       };
3217     } catch (std::exception& e) {
3218       {
3219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3220       };
3221     } catch (Dali::DaliException e) {
3222       {
3223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3224       };
3225     } catch (...) {
3226       {
3227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3228       };
3229     }
3230   }
3231
3232 }
3233
3234
3235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3236   unsigned int jresult ;
3237   uintp *arg1 = (uintp *) 0 ;
3238   unsigned int result;
3239
3240   arg1 = (uintp *)jarg1;
3241   {
3242     try {
3243       result = (unsigned int)uintp_value(arg1);
3244     } catch (std::out_of_range& e) {
3245       {
3246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3247       };
3248     } catch (std::exception& e) {
3249       {
3250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3251       };
3252     } catch (Dali::DaliException e) {
3253       {
3254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3255       };
3256     } catch (...) {
3257       {
3258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3259       };
3260     }
3261   }
3262
3263   jresult = result;
3264   return jresult;
3265 }
3266
3267
3268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3269   void * jresult ;
3270   uintp *arg1 = (uintp *) 0 ;
3271   unsigned int *result = 0 ;
3272
3273   arg1 = (uintp *)jarg1;
3274   {
3275     try {
3276       result = (unsigned int *)uintp_cast(arg1);
3277     } catch (std::out_of_range& e) {
3278       {
3279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3280       };
3281     } catch (std::exception& e) {
3282       {
3283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3284       };
3285     } catch (Dali::DaliException e) {
3286       {
3287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3288       };
3289     } catch (...) {
3290       {
3291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3292       };
3293     }
3294   }
3295
3296   jresult = (void *)result;
3297   return jresult;
3298 }
3299
3300
3301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3302   void * jresult ;
3303   unsigned int *arg1 = (unsigned int *) 0 ;
3304   uintp *result = 0 ;
3305
3306   arg1 = (unsigned int *)jarg1;
3307   {
3308     try {
3309       result = (uintp *)uintp_frompointer(arg1);
3310     } catch (std::out_of_range& e) {
3311       {
3312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3313       };
3314     } catch (std::exception& e) {
3315       {
3316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3317       };
3318     } catch (Dali::DaliException e) {
3319       {
3320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3321       };
3322     } catch (...) {
3323       {
3324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3325       };
3326     }
3327   }
3328
3329   jresult = (void *)result;
3330   return jresult;
3331 }
3332
3333
3334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3335   void * jresult ;
3336   ushortp *result = 0 ;
3337
3338   {
3339     try {
3340       result = (ushortp *)new_ushortp();
3341     } catch (std::out_of_range& e) {
3342       {
3343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3344       };
3345     } catch (std::exception& e) {
3346       {
3347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3348       };
3349     } catch (Dali::DaliException e) {
3350       {
3351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3352       };
3353     } catch (...) {
3354       {
3355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3356       };
3357     }
3358   }
3359
3360   jresult = (void *)result;
3361   return jresult;
3362 }
3363
3364
3365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3366   ushortp *arg1 = (ushortp *) 0 ;
3367
3368   arg1 = (ushortp *)jarg1;
3369   {
3370     try {
3371       delete_ushortp(arg1);
3372     } catch (std::out_of_range& e) {
3373       {
3374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3375       };
3376     } catch (std::exception& e) {
3377       {
3378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3379       };
3380     } catch (Dali::DaliException e) {
3381       {
3382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3383       };
3384     } catch (...) {
3385       {
3386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3387       };
3388     }
3389   }
3390
3391 }
3392
3393
3394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3395   ushortp *arg1 = (ushortp *) 0 ;
3396   unsigned short arg2 ;
3397
3398   arg1 = (ushortp *)jarg1;
3399   arg2 = (unsigned short)jarg2;
3400   {
3401     try {
3402       ushortp_assign(arg1,arg2);
3403     } catch (std::out_of_range& e) {
3404       {
3405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3406       };
3407     } catch (std::exception& e) {
3408       {
3409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3410       };
3411     } catch (Dali::DaliException e) {
3412       {
3413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3414       };
3415     } catch (...) {
3416       {
3417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3418       };
3419     }
3420   }
3421
3422 }
3423
3424
3425 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3426   unsigned short jresult ;
3427   ushortp *arg1 = (ushortp *) 0 ;
3428   unsigned short result;
3429
3430   arg1 = (ushortp *)jarg1;
3431   {
3432     try {
3433       result = (unsigned short)ushortp_value(arg1);
3434     } catch (std::out_of_range& e) {
3435       {
3436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3437       };
3438     } catch (std::exception& e) {
3439       {
3440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3441       };
3442     } catch (Dali::DaliException e) {
3443       {
3444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3445       };
3446     } catch (...) {
3447       {
3448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3449       };
3450     }
3451   }
3452
3453   jresult = result;
3454   return jresult;
3455 }
3456
3457
3458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3459   void * jresult ;
3460   ushortp *arg1 = (ushortp *) 0 ;
3461   unsigned short *result = 0 ;
3462
3463   arg1 = (ushortp *)jarg1;
3464   {
3465     try {
3466       result = (unsigned short *)ushortp_cast(arg1);
3467     } catch (std::out_of_range& e) {
3468       {
3469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3470       };
3471     } catch (std::exception& e) {
3472       {
3473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3474       };
3475     } catch (Dali::DaliException e) {
3476       {
3477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3478       };
3479     } catch (...) {
3480       {
3481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3482       };
3483     }
3484   }
3485
3486   jresult = (void *)result;
3487   return jresult;
3488 }
3489
3490
3491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3492   void * jresult ;
3493   unsigned short *arg1 = (unsigned short *) 0 ;
3494   ushortp *result = 0 ;
3495
3496   arg1 = (unsigned short *)jarg1;
3497   {
3498     try {
3499       result = (ushortp *)ushortp_frompointer(arg1);
3500     } catch (std::out_of_range& e) {
3501       {
3502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3503       };
3504     } catch (std::exception& e) {
3505       {
3506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3507       };
3508     } catch (Dali::DaliException e) {
3509       {
3510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3511       };
3512     } catch (...) {
3513       {
3514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3515       };
3516     }
3517   }
3518
3519   jresult = (void *)result;
3520   return jresult;
3521 }
3522
3523
3524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3525   unsigned int jresult ;
3526   int arg1 ;
3527   unsigned int result;
3528
3529   arg1 = (int)jarg1;
3530   {
3531     try {
3532       result = (unsigned int)int_to_uint(arg1);
3533     } catch (std::out_of_range& e) {
3534       {
3535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3536       };
3537     } catch (std::exception& e) {
3538       {
3539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3540       };
3541     } catch (Dali::DaliException e) {
3542       {
3543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3544       };
3545     } catch (...) {
3546       {
3547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3548       };
3549     }
3550   }
3551
3552   jresult = result;
3553   return jresult;
3554 }
3555
3556
3557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3558   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3559
3560   arg1 = (Dali::RefObject *)jarg1;
3561   {
3562     try {
3563       (arg1)->Reference();
3564     } catch (std::out_of_range& e) {
3565       {
3566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3567       };
3568     } catch (std::exception& e) {
3569       {
3570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3571       };
3572     } catch (Dali::DaliException e) {
3573       {
3574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3575       };
3576     } catch (...) {
3577       {
3578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3579       };
3580     }
3581   }
3582
3583 }
3584
3585
3586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3587   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3588
3589   arg1 = (Dali::RefObject *)jarg1;
3590   {
3591     try {
3592       (arg1)->Unreference();
3593     } catch (std::out_of_range& e) {
3594       {
3595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3596       };
3597     } catch (std::exception& e) {
3598       {
3599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3600       };
3601     } catch (Dali::DaliException e) {
3602       {
3603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3604       };
3605     } catch (...) {
3606       {
3607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3608       };
3609     }
3610   }
3611
3612 }
3613
3614
3615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3616   int jresult ;
3617   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3618   int result;
3619
3620   arg1 = (Dali::RefObject *)jarg1;
3621   {
3622     try {
3623       result = (int)(arg1)->ReferenceCount();
3624     } catch (std::out_of_range& e) {
3625       {
3626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3627       };
3628     } catch (std::exception& e) {
3629       {
3630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3631       };
3632     } catch (Dali::DaliException e) {
3633       {
3634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3635       };
3636     } catch (...) {
3637       {
3638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3639       };
3640     }
3641   }
3642
3643   jresult = result;
3644   return jresult;
3645 }
3646
3647
3648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3649   void * jresult ;
3650   Dali::Any *result = 0 ;
3651
3652   {
3653     try {
3654       result = (Dali::Any *)new Dali::Any();
3655     } catch (std::out_of_range& e) {
3656       {
3657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3658       };
3659     } catch (std::exception& e) {
3660       {
3661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3662       };
3663     } catch (Dali::DaliException e) {
3664       {
3665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3666       };
3667     } catch (...) {
3668       {
3669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3670       };
3671     }
3672   }
3673
3674   jresult = (void *)result;
3675   return jresult;
3676 }
3677
3678
3679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3680   Dali::Any *arg1 = (Dali::Any *) 0 ;
3681
3682   arg1 = (Dali::Any *)jarg1;
3683   {
3684     try {
3685       delete arg1;
3686     } catch (std::out_of_range& e) {
3687       {
3688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3689       };
3690     } catch (std::exception& e) {
3691       {
3692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3693       };
3694     } catch (Dali::DaliException e) {
3695       {
3696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3697       };
3698     } catch (...) {
3699       {
3700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3701       };
3702     }
3703   }
3704
3705 }
3706
3707
3708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3709   char *arg1 = (char *) 0 ;
3710
3711   arg1 = (char *)jarg1;
3712   {
3713     try {
3714       Dali::Any::AssertAlways((char const *)arg1);
3715     } catch (std::out_of_range& e) {
3716       {
3717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3718       };
3719     } catch (std::exception& e) {
3720       {
3721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3722       };
3723     } catch (Dali::DaliException e) {
3724       {
3725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3726       };
3727     } catch (...) {
3728       {
3729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3730       };
3731     }
3732   }
3733
3734 }
3735
3736
3737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3738   void * jresult ;
3739   Dali::Any *arg1 = 0 ;
3740   Dali::Any *result = 0 ;
3741
3742   arg1 = (Dali::Any *)jarg1;
3743   if (!arg1) {
3744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3745     return 0;
3746   }
3747   {
3748     try {
3749       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3750     } catch (std::out_of_range& e) {
3751       {
3752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3753       };
3754     } catch (std::exception& e) {
3755       {
3756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3757       };
3758     } catch (Dali::DaliException e) {
3759       {
3760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3761       };
3762     } catch (...) {
3763       {
3764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3765       };
3766     }
3767   }
3768
3769   jresult = (void *)result;
3770   return jresult;
3771 }
3772
3773
3774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3775   void * jresult ;
3776   Dali::Any *arg1 = (Dali::Any *) 0 ;
3777   Dali::Any *arg2 = 0 ;
3778   Dali::Any *result = 0 ;
3779
3780   arg1 = (Dali::Any *)jarg1;
3781   arg2 = (Dali::Any *)jarg2;
3782   if (!arg2) {
3783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3784     return 0;
3785   }
3786   {
3787     try {
3788       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3789     } catch (std::out_of_range& e) {
3790       {
3791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3792       };
3793     } catch (std::exception& e) {
3794       {
3795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3796       };
3797     } catch (Dali::DaliException e) {
3798       {
3799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3800       };
3801     } catch (...) {
3802       {
3803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3804       };
3805     }
3806   }
3807
3808   jresult = (void *)result;
3809   return jresult;
3810 }
3811
3812
3813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3814   void * jresult ;
3815   Dali::Any *arg1 = (Dali::Any *) 0 ;
3816   std::type_info *result = 0 ;
3817
3818   arg1 = (Dali::Any *)jarg1;
3819   {
3820     try {
3821       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3822     } catch (std::out_of_range& e) {
3823       {
3824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3825       };
3826     } catch (std::exception& e) {
3827       {
3828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3829       };
3830     } catch (Dali::DaliException e) {
3831       {
3832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3833       };
3834     } catch (...) {
3835       {
3836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3837       };
3838     }
3839   }
3840
3841   jresult = (void *)result;
3842   return jresult;
3843 }
3844
3845
3846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3847   unsigned int jresult ;
3848   Dali::Any *arg1 = (Dali::Any *) 0 ;
3849   bool result;
3850
3851   arg1 = (Dali::Any *)jarg1;
3852   {
3853     try {
3854       result = (bool)((Dali::Any const *)arg1)->Empty();
3855     } catch (std::out_of_range& e) {
3856       {
3857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3858       };
3859     } catch (std::exception& e) {
3860       {
3861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3862       };
3863     } catch (Dali::DaliException e) {
3864       {
3865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3866       };
3867     } catch (...) {
3868       {
3869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3870       };
3871     }
3872   }
3873
3874   jresult = result;
3875   return jresult;
3876 }
3877
3878
3879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3880   void * jresult ;
3881   std::type_info *arg1 = 0 ;
3882   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3883   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3884   Dali::Any::AnyContainerBase *result = 0 ;
3885
3886   arg1 = (std::type_info *)jarg1;
3887   if (!arg1) {
3888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3889     return 0;
3890   }
3891   arg2 = (Dali::Any::CloneFunc)jarg2;
3892   arg3 = (Dali::Any::DeleteFunc)jarg3;
3893   {
3894     try {
3895       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3896     } catch (std::out_of_range& e) {
3897       {
3898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3899       };
3900     } catch (std::exception& e) {
3901       {
3902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3903       };
3904     } catch (Dali::DaliException e) {
3905       {
3906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3907       };
3908     } catch (...) {
3909       {
3910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3911       };
3912     }
3913   }
3914
3915   jresult = (void *)result;
3916   return jresult;
3917 }
3918
3919
3920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3921   void * jresult ;
3922   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3923   std::type_info *result = 0 ;
3924
3925   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3926   {
3927     try {
3928       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3929     } catch (std::out_of_range& e) {
3930       {
3931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3932       };
3933     } catch (std::exception& e) {
3934       {
3935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3936       };
3937     } catch (Dali::DaliException e) {
3938       {
3939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3940       };
3941     } catch (...) {
3942       {
3943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3944       };
3945     }
3946   }
3947
3948   jresult = (void *)result;
3949   return jresult;
3950 }
3951
3952
3953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3954   void * jresult ;
3955   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3956   ::std::type_info *result = 0 ;
3957
3958   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3959   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3960   jresult = (void *)result;
3961   return jresult;
3962 }
3963
3964
3965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3966   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3967   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3968
3969   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3970   arg2 = (Dali::Any::CloneFunc)jarg2;
3971   if (arg1) (arg1)->mCloneFunc = arg2;
3972 }
3973
3974
3975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3976   void * jresult ;
3977   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3978   Dali::Any::CloneFunc result;
3979
3980   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3981   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3982   jresult = (void *)result;
3983   return jresult;
3984 }
3985
3986
3987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3988   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3989   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3990
3991   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3992   arg2 = (Dali::Any::DeleteFunc)jarg2;
3993   if (arg1) (arg1)->mDeleteFunc = arg2;
3994 }
3995
3996
3997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3998   void * jresult ;
3999   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4000   Dali::Any::DeleteFunc result;
4001
4002   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4003   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4004   jresult = (void *)result;
4005   return jresult;
4006 }
4007
4008
4009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4010   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4011
4012   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4013   {
4014     try {
4015       delete arg1;
4016     } catch (std::out_of_range& e) {
4017       {
4018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4019       };
4020     } catch (std::exception& e) {
4021       {
4022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4023       };
4024     } catch (Dali::DaliException e) {
4025       {
4026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4027       };
4028     } catch (...) {
4029       {
4030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4031       };
4032     }
4033   }
4034
4035 }
4036
4037
4038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4039   Dali::Any *arg1 = (Dali::Any *) 0 ;
4040   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4041
4042   arg1 = (Dali::Any *)jarg1;
4043   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4044   if (arg1) (arg1)->mContainer = arg2;
4045 }
4046
4047
4048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4049   void * jresult ;
4050   Dali::Any *arg1 = (Dali::Any *) 0 ;
4051   Dali::Any::AnyContainerBase *result = 0 ;
4052
4053   arg1 = (Dali::Any *)jarg1;
4054   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4055   jresult = (void *)result;
4056   return jresult;
4057 }
4058
4059
4060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4061   char *arg1 = (char *) 0 ;
4062   char *arg2 = (char *) 0 ;
4063
4064   arg1 = (char *)jarg1;
4065   arg2 = (char *)jarg2;
4066   {
4067     try {
4068       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4069     } catch (std::out_of_range& e) {
4070       {
4071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4072       };
4073     } catch (std::exception& e) {
4074       {
4075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4076       };
4077     } catch (Dali::DaliException e) {
4078       {
4079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4080       };
4081     } catch (...) {
4082       {
4083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4084       };
4085     }
4086   }
4087
4088 }
4089
4090
4091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4092   void * jresult ;
4093   char *arg1 = (char *) 0 ;
4094   char *arg2 = (char *) 0 ;
4095   Dali::DaliException *result = 0 ;
4096
4097   arg1 = (char *)jarg1;
4098   arg2 = (char *)jarg2;
4099   {
4100     try {
4101       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4102     } catch (std::out_of_range& e) {
4103       {
4104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4105       };
4106     } catch (std::exception& e) {
4107       {
4108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4109       };
4110     } catch (Dali::DaliException e) {
4111       {
4112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4113       };
4114     } catch (...) {
4115       {
4116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4117       };
4118     }
4119   }
4120
4121   jresult = (void *)result;
4122   return jresult;
4123 }
4124
4125
4126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4127   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4128   std::string arg2 = std::string(jarg2);
4129
4130   arg1 = (Dali::DaliException *)jarg1;
4131   {
4132     if (!arg2.empty()) {
4133       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4134     } else {
4135       arg1->location = 0;
4136     }
4137   }
4138 }
4139
4140 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4141   char * jresult ;
4142   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4143   char *result = 0 ;
4144
4145   arg1 = (Dali::DaliException *)jarg1;
4146   result = (char *) ((arg1)->location);
4147   jresult = SWIG_csharp_string_callback((const char *)result);
4148   return jresult;
4149 }
4150
4151
4152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4153   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4154   std::string arg2 = std::string(jarg2);
4155
4156   arg1 = (Dali::DaliException *)jarg1;
4157   {
4158     if (!arg2.empty()) {
4159       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4160     } else {
4161       arg1->condition = 0;
4162     }
4163   }
4164 }
4165
4166
4167 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4168   char * jresult ;
4169   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4170   char *result = 0 ;
4171
4172   arg1 = (Dali::DaliException *)jarg1;
4173   result = (char *) ((arg1)->condition);
4174   jresult = SWIG_csharp_string_callback((const char *)result);
4175   return jresult;
4176 }
4177
4178
4179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4180   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4181
4182   arg1 = (Dali::DaliException *)jarg1;
4183   {
4184     try {
4185       delete arg1;
4186     } catch (std::out_of_range& e) {
4187       {
4188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4189       };
4190     } catch (std::exception& e) {
4191       {
4192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4193       };
4194     } catch (Dali::DaliException e) {
4195       {
4196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4197       };
4198     } catch (...) {
4199       {
4200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4201       };
4202     }
4203   }
4204
4205 }
4206
4207
4208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4209   void * jresult ;
4210   Dali::Vector2 *result = 0 ;
4211
4212   {
4213     try {
4214       result = (Dali::Vector2 *)new Dali::Vector2();
4215     } catch (std::out_of_range& e) {
4216       {
4217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4218       };
4219     } catch (std::exception& e) {
4220       {
4221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4222       };
4223     } catch (Dali::DaliException e) {
4224       {
4225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4226       };
4227     } catch (...) {
4228       {
4229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4230       };
4231     }
4232   }
4233
4234   jresult = (void *)result;
4235   return jresult;
4236 }
4237
4238
4239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4240   void * jresult ;
4241   float arg1 ;
4242   float arg2 ;
4243   Dali::Vector2 *result = 0 ;
4244
4245   arg1 = (float)jarg1;
4246   arg2 = (float)jarg2;
4247   {
4248     try {
4249       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4250     } catch (std::out_of_range& e) {
4251       {
4252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4253       };
4254     } catch (std::exception& e) {
4255       {
4256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4257       };
4258     } catch (Dali::DaliException e) {
4259       {
4260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4261       };
4262     } catch (...) {
4263       {
4264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4265       };
4266     }
4267   }
4268
4269   jresult = (void *)result;
4270   return jresult;
4271 }
4272
4273
4274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4275   void * jresult ;
4276   float *arg1 = (float *) 0 ;
4277   Dali::Vector2 *result = 0 ;
4278
4279   arg1 = jarg1;
4280   {
4281     try {
4282       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4283     } catch (std::out_of_range& e) {
4284       {
4285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4286       };
4287     } catch (std::exception& e) {
4288       {
4289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4290       };
4291     } catch (Dali::DaliException e) {
4292       {
4293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4294       };
4295     } catch (...) {
4296       {
4297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4298       };
4299     }
4300   }
4301
4302   jresult = (void *)result;
4303
4304
4305   return jresult;
4306 }
4307
4308
4309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4310   void * jresult ;
4311   Dali::Vector3 *arg1 = 0 ;
4312   Dali::Vector2 *result = 0 ;
4313
4314   arg1 = (Dali::Vector3 *)jarg1;
4315   if (!arg1) {
4316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4317     return 0;
4318   }
4319   {
4320     try {
4321       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4322     } catch (std::out_of_range& e) {
4323       {
4324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4325       };
4326     } catch (std::exception& e) {
4327       {
4328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4329       };
4330     } catch (Dali::DaliException e) {
4331       {
4332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4333       };
4334     } catch (...) {
4335       {
4336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4337       };
4338     }
4339   }
4340
4341   jresult = (void *)result;
4342   return jresult;
4343 }
4344
4345
4346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4347   void * jresult ;
4348   Dali::Vector4 *arg1 = 0 ;
4349   Dali::Vector2 *result = 0 ;
4350
4351   arg1 = (Dali::Vector4 *)jarg1;
4352   if (!arg1) {
4353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4354     return 0;
4355   }
4356   {
4357     try {
4358       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4359     } catch (std::out_of_range& e) {
4360       {
4361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4362       };
4363     } catch (std::exception& e) {
4364       {
4365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4366       };
4367     } catch (Dali::DaliException e) {
4368       {
4369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4370       };
4371     } catch (...) {
4372       {
4373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4374       };
4375     }
4376   }
4377
4378   jresult = (void *)result;
4379   return jresult;
4380 }
4381
4382
4383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4384   void * jresult ;
4385   Dali::Vector2 *result = 0 ;
4386
4387   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4388   jresult = (void *)result;
4389   return jresult;
4390 }
4391
4392
4393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4394   void * jresult ;
4395   Dali::Vector2 *result = 0 ;
4396
4397   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4398   jresult = (void *)result;
4399   return jresult;
4400 }
4401
4402
4403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4404   void * jresult ;
4405   Dali::Vector2 *result = 0 ;
4406
4407   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4408   jresult = (void *)result;
4409   return jresult;
4410 }
4411
4412
4413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4414   void * jresult ;
4415   Dali::Vector2 *result = 0 ;
4416
4417   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4418   jresult = (void *)result;
4419   return jresult;
4420 }
4421
4422
4423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4424   void * jresult ;
4425   Dali::Vector2 *result = 0 ;
4426
4427   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4428   jresult = (void *)result;
4429   return jresult;
4430 }
4431
4432
4433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4434   void * jresult ;
4435   Dali::Vector2 *result = 0 ;
4436
4437   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4438   jresult = (void *)result;
4439   return jresult;
4440 }
4441
4442
4443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4444   void * jresult ;
4445   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4446   float *arg2 = (float *) 0 ;
4447   Dali::Vector2 *result = 0 ;
4448
4449   arg1 = (Dali::Vector2 *)jarg1;
4450   arg2 = jarg2;
4451   {
4452     try {
4453       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4454     } catch (std::out_of_range& e) {
4455       {
4456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4457       };
4458     } catch (std::exception& e) {
4459       {
4460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4461       };
4462     } catch (Dali::DaliException e) {
4463       {
4464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4465       };
4466     } catch (...) {
4467       {
4468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4469       };
4470     }
4471   }
4472
4473   jresult = (void *)result;
4474
4475
4476   return jresult;
4477 }
4478
4479
4480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4481   void * jresult ;
4482   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4483   Dali::Vector3 *arg2 = 0 ;
4484   Dali::Vector2 *result = 0 ;
4485
4486   arg1 = (Dali::Vector2 *)jarg1;
4487   arg2 = (Dali::Vector3 *)jarg2;
4488   if (!arg2) {
4489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4490     return 0;
4491   }
4492   {
4493     try {
4494       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4495     } catch (std::out_of_range& e) {
4496       {
4497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4498       };
4499     } catch (std::exception& e) {
4500       {
4501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4502       };
4503     } catch (Dali::DaliException e) {
4504       {
4505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4506       };
4507     } catch (...) {
4508       {
4509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4510       };
4511     }
4512   }
4513
4514   jresult = (void *)result;
4515   return jresult;
4516 }
4517
4518
4519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4520   void * jresult ;
4521   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4522   Dali::Vector4 *arg2 = 0 ;
4523   Dali::Vector2 *result = 0 ;
4524
4525   arg1 = (Dali::Vector2 *)jarg1;
4526   arg2 = (Dali::Vector4 *)jarg2;
4527   if (!arg2) {
4528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4529     return 0;
4530   }
4531   {
4532     try {
4533       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4534     } catch (std::out_of_range& e) {
4535       {
4536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4537       };
4538     } catch (std::exception& e) {
4539       {
4540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4541       };
4542     } catch (Dali::DaliException e) {
4543       {
4544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4545       };
4546     } catch (...) {
4547       {
4548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4549       };
4550     }
4551   }
4552
4553   jresult = (void *)result;
4554   return jresult;
4555 }
4556
4557
4558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4559   void * jresult ;
4560   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4561   Dali::Vector2 *arg2 = 0 ;
4562   Dali::Vector2 result;
4563
4564   arg1 = (Dali::Vector2 *)jarg1;
4565   arg2 = (Dali::Vector2 *)jarg2;
4566   if (!arg2) {
4567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4568     return 0;
4569   }
4570   {
4571     try {
4572       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4573     } catch (std::out_of_range& e) {
4574       {
4575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4576       };
4577     } catch (std::exception& e) {
4578       {
4579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4580       };
4581     } catch (Dali::DaliException e) {
4582       {
4583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4584       };
4585     } catch (...) {
4586       {
4587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4588       };
4589     }
4590   }
4591
4592   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4593   return jresult;
4594 }
4595
4596
4597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4598   void * jresult ;
4599   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4600   Dali::Vector2 *arg2 = 0 ;
4601   Dali::Vector2 *result = 0 ;
4602
4603   arg1 = (Dali::Vector2 *)jarg1;
4604   arg2 = (Dali::Vector2 *)jarg2;
4605   if (!arg2) {
4606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4607     return 0;
4608   }
4609   {
4610     try {
4611       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4612     } catch (std::out_of_range& e) {
4613       {
4614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4615       };
4616     } catch (std::exception& e) {
4617       {
4618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4619       };
4620     } catch (Dali::DaliException e) {
4621       {
4622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4623       };
4624     } catch (...) {
4625       {
4626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4627       };
4628     }
4629   }
4630
4631   jresult = (void *)result;
4632   return jresult;
4633 }
4634
4635
4636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4637   void * jresult ;
4638   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4639   Dali::Vector2 *arg2 = 0 ;
4640   Dali::Vector2 result;
4641
4642   arg1 = (Dali::Vector2 *)jarg1;
4643   arg2 = (Dali::Vector2 *)jarg2;
4644   if (!arg2) {
4645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4646     return 0;
4647   }
4648   {
4649     try {
4650       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4651     } catch (std::out_of_range& e) {
4652       {
4653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4654       };
4655     } catch (std::exception& e) {
4656       {
4657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4658       };
4659     } catch (Dali::DaliException e) {
4660       {
4661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4662       };
4663     } catch (...) {
4664       {
4665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4666       };
4667     }
4668   }
4669
4670   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4671   return jresult;
4672 }
4673
4674
4675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4676   void * jresult ;
4677   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4678   Dali::Vector2 *arg2 = 0 ;
4679   Dali::Vector2 *result = 0 ;
4680
4681   arg1 = (Dali::Vector2 *)jarg1;
4682   arg2 = (Dali::Vector2 *)jarg2;
4683   if (!arg2) {
4684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4685     return 0;
4686   }
4687   {
4688     try {
4689       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4690     } catch (std::out_of_range& e) {
4691       {
4692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4693       };
4694     } catch (std::exception& e) {
4695       {
4696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4697       };
4698     } catch (Dali::DaliException e) {
4699       {
4700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4701       };
4702     } catch (...) {
4703       {
4704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4705       };
4706     }
4707   }
4708
4709   jresult = (void *)result;
4710   return jresult;
4711 }
4712
4713
4714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4715   void * jresult ;
4716   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4717   Dali::Vector2 *arg2 = 0 ;
4718   Dali::Vector2 result;
4719
4720   arg1 = (Dali::Vector2 *)jarg1;
4721   arg2 = (Dali::Vector2 *)jarg2;
4722   if (!arg2) {
4723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4724     return 0;
4725   }
4726   {
4727     try {
4728       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4729     } catch (std::out_of_range& e) {
4730       {
4731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4732       };
4733     } catch (std::exception& e) {
4734       {
4735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4736       };
4737     } catch (Dali::DaliException e) {
4738       {
4739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4740       };
4741     } catch (...) {
4742       {
4743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4744       };
4745     }
4746   }
4747
4748   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4749   return jresult;
4750 }
4751
4752
4753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4754   void * jresult ;
4755   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4756   float arg2 ;
4757   Dali::Vector2 result;
4758
4759   arg1 = (Dali::Vector2 *)jarg1;
4760   arg2 = (float)jarg2;
4761   {
4762     try {
4763       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4764     } catch (std::out_of_range& e) {
4765       {
4766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4767       };
4768     } catch (std::exception& e) {
4769       {
4770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4771       };
4772     } catch (Dali::DaliException e) {
4773       {
4774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4775       };
4776     } catch (...) {
4777       {
4778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4779       };
4780     }
4781   }
4782
4783   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4784   return jresult;
4785 }
4786
4787
4788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4789   void * jresult ;
4790   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4791   Dali::Vector2 *arg2 = 0 ;
4792   Dali::Vector2 *result = 0 ;
4793
4794   arg1 = (Dali::Vector2 *)jarg1;
4795   arg2 = (Dali::Vector2 *)jarg2;
4796   if (!arg2) {
4797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4798     return 0;
4799   }
4800   {
4801     try {
4802       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4803     } catch (std::out_of_range& e) {
4804       {
4805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4806       };
4807     } catch (std::exception& e) {
4808       {
4809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4810       };
4811     } catch (Dali::DaliException e) {
4812       {
4813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4814       };
4815     } catch (...) {
4816       {
4817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4818       };
4819     }
4820   }
4821
4822   jresult = (void *)result;
4823   return jresult;
4824 }
4825
4826
4827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4828   void * jresult ;
4829   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4830   float arg2 ;
4831   Dali::Vector2 *result = 0 ;
4832
4833   arg1 = (Dali::Vector2 *)jarg1;
4834   arg2 = (float)jarg2;
4835   {
4836     try {
4837       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4838     } catch (std::out_of_range& e) {
4839       {
4840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4841       };
4842     } catch (std::exception& e) {
4843       {
4844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4845       };
4846     } catch (Dali::DaliException e) {
4847       {
4848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4849       };
4850     } catch (...) {
4851       {
4852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4853       };
4854     }
4855   }
4856
4857   jresult = (void *)result;
4858   return jresult;
4859 }
4860
4861
4862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4863   void * jresult ;
4864   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4865   Dali::Vector2 *arg2 = 0 ;
4866   Dali::Vector2 result;
4867
4868   arg1 = (Dali::Vector2 *)jarg1;
4869   arg2 = (Dali::Vector2 *)jarg2;
4870   if (!arg2) {
4871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4872     return 0;
4873   }
4874   {
4875     try {
4876       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4877     } catch (std::out_of_range& e) {
4878       {
4879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4880       };
4881     } catch (std::exception& e) {
4882       {
4883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4884       };
4885     } catch (Dali::DaliException e) {
4886       {
4887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4888       };
4889     } catch (...) {
4890       {
4891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4892       };
4893     }
4894   }
4895
4896   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4897   return jresult;
4898 }
4899
4900
4901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4902   void * jresult ;
4903   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4904   float arg2 ;
4905   Dali::Vector2 result;
4906
4907   arg1 = (Dali::Vector2 *)jarg1;
4908   arg2 = (float)jarg2;
4909   {
4910     try {
4911       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4912     } catch (std::out_of_range& e) {
4913       {
4914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4915       };
4916     } catch (std::exception& e) {
4917       {
4918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4919       };
4920     } catch (Dali::DaliException e) {
4921       {
4922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4923       };
4924     } catch (...) {
4925       {
4926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4927       };
4928     }
4929   }
4930
4931   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4932   return jresult;
4933 }
4934
4935
4936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4937   void * jresult ;
4938   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4939   Dali::Vector2 *arg2 = 0 ;
4940   Dali::Vector2 *result = 0 ;
4941
4942   arg1 = (Dali::Vector2 *)jarg1;
4943   arg2 = (Dali::Vector2 *)jarg2;
4944   if (!arg2) {
4945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4946     return 0;
4947   }
4948   {
4949     try {
4950       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4951     } catch (std::out_of_range& e) {
4952       {
4953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4954       };
4955     } catch (std::exception& e) {
4956       {
4957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4958       };
4959     } catch (Dali::DaliException e) {
4960       {
4961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4962       };
4963     } catch (...) {
4964       {
4965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4966       };
4967     }
4968   }
4969
4970   jresult = (void *)result;
4971   return jresult;
4972 }
4973
4974
4975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4976   void * jresult ;
4977   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4978   float arg2 ;
4979   Dali::Vector2 *result = 0 ;
4980
4981   arg1 = (Dali::Vector2 *)jarg1;
4982   arg2 = (float)jarg2;
4983   {
4984     try {
4985       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4986     } catch (std::out_of_range& e) {
4987       {
4988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4989       };
4990     } catch (std::exception& e) {
4991       {
4992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4993       };
4994     } catch (Dali::DaliException e) {
4995       {
4996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4997       };
4998     } catch (...) {
4999       {
5000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5001       };
5002     }
5003   }
5004
5005   jresult = (void *)result;
5006   return jresult;
5007 }
5008
5009
5010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5011   void * jresult ;
5012   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5013   Dali::Vector2 result;
5014
5015   arg1 = (Dali::Vector2 *)jarg1;
5016   {
5017     try {
5018       result = ((Dali::Vector2 const *)arg1)->operator -();
5019     } catch (std::out_of_range& e) {
5020       {
5021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5022       };
5023     } catch (std::exception& e) {
5024       {
5025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5026       };
5027     } catch (Dali::DaliException e) {
5028       {
5029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5030       };
5031     } catch (...) {
5032       {
5033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5034       };
5035     }
5036   }
5037
5038   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5039   return jresult;
5040 }
5041
5042
5043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5044   unsigned int jresult ;
5045   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5046   Dali::Vector2 *arg2 = 0 ;
5047   bool result;
5048
5049   arg1 = (Dali::Vector2 *)jarg1;
5050   arg2 = (Dali::Vector2 *)jarg2;
5051   if (!arg2) {
5052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5053     return 0;
5054   }
5055   {
5056     try {
5057       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5058     } catch (std::out_of_range& e) {
5059       {
5060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5061       };
5062     } catch (std::exception& e) {
5063       {
5064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5065       };
5066     } catch (Dali::DaliException e) {
5067       {
5068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5069       };
5070     } catch (...) {
5071       {
5072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5073       };
5074     }
5075   }
5076
5077   jresult = result;
5078   return jresult;
5079 }
5080
5081
5082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5083   unsigned int jresult ;
5084   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5085   Dali::Vector2 *arg2 = 0 ;
5086   bool result;
5087
5088   arg1 = (Dali::Vector2 *)jarg1;
5089   arg2 = (Dali::Vector2 *)jarg2;
5090   if (!arg2) {
5091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5092     return 0;
5093   }
5094   {
5095     try {
5096       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5097     } catch (std::out_of_range& e) {
5098       {
5099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5100       };
5101     } catch (std::exception& e) {
5102       {
5103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5104       };
5105     } catch (Dali::DaliException e) {
5106       {
5107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5108       };
5109     } catch (...) {
5110       {
5111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5112       };
5113     }
5114   }
5115
5116   jresult = result;
5117   return jresult;
5118 }
5119
5120
5121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5122   float jresult ;
5123   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5124   unsigned int arg2 ;
5125   float *result = 0 ;
5126
5127   arg1 = (Dali::Vector2 *)jarg1;
5128   arg2 = (unsigned int)jarg2;
5129   {
5130     try {
5131       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5132     } catch (std::out_of_range& e) {
5133       {
5134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5135       };
5136     } catch (std::exception& e) {
5137       {
5138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5139       };
5140     } catch (Dali::DaliException e) {
5141       {
5142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5143       };
5144     } catch (...) {
5145       {
5146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5147       };
5148     }
5149   }
5150
5151   jresult = *result;
5152   return jresult;
5153 }
5154
5155
5156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5157   float jresult ;
5158   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5159   float result;
5160
5161   arg1 = (Dali::Vector2 *)jarg1;
5162   {
5163     try {
5164       result = (float)((Dali::Vector2 const *)arg1)->Length();
5165     } catch (std::out_of_range& e) {
5166       {
5167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5168       };
5169     } catch (std::exception& e) {
5170       {
5171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5172       };
5173     } catch (Dali::DaliException e) {
5174       {
5175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5176       };
5177     } catch (...) {
5178       {
5179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5180       };
5181     }
5182   }
5183
5184   jresult = result;
5185   return jresult;
5186 }
5187
5188
5189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5190   float jresult ;
5191   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5192   float result;
5193
5194   arg1 = (Dali::Vector2 *)jarg1;
5195   {
5196     try {
5197       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5198     } catch (std::out_of_range& e) {
5199       {
5200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5201       };
5202     } catch (std::exception& e) {
5203       {
5204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5205       };
5206     } catch (Dali::DaliException e) {
5207       {
5208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5209       };
5210     } catch (...) {
5211       {
5212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5213       };
5214     }
5215   }
5216
5217   jresult = result;
5218   return jresult;
5219 }
5220
5221
5222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5223   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5224
5225   arg1 = (Dali::Vector2 *)jarg1;
5226   {
5227     try {
5228       (arg1)->Normalize();
5229     } catch (std::out_of_range& e) {
5230       {
5231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5232       };
5233     } catch (std::exception& e) {
5234       {
5235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5236       };
5237     } catch (Dali::DaliException e) {
5238       {
5239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5240       };
5241     } catch (...) {
5242       {
5243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5244       };
5245     }
5246   }
5247
5248 }
5249
5250
5251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5252   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5253   Dali::Vector2 *arg2 = 0 ;
5254   Dali::Vector2 *arg3 = 0 ;
5255
5256   arg1 = (Dali::Vector2 *)jarg1;
5257   arg2 = (Dali::Vector2 *)jarg2;
5258   if (!arg2) {
5259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5260     return ;
5261   }
5262   arg3 = (Dali::Vector2 *)jarg3;
5263   if (!arg3) {
5264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5265     return ;
5266   }
5267   {
5268     try {
5269       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5270     } catch (std::out_of_range& e) {
5271       {
5272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5273       };
5274     } catch (std::exception& e) {
5275       {
5276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5277       };
5278     } catch (Dali::DaliException e) {
5279       {
5280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5281       };
5282     } catch (...) {
5283       {
5284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5285       };
5286     }
5287   }
5288
5289 }
5290
5291
5292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5293   void * jresult ;
5294   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5295   float *result = 0 ;
5296
5297   arg1 = (Dali::Vector2 *)jarg1;
5298   {
5299     try {
5300       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5301     } catch (std::out_of_range& e) {
5302       {
5303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5304       };
5305     } catch (std::exception& e) {
5306       {
5307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5308       };
5309     } catch (Dali::DaliException e) {
5310       {
5311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5312       };
5313     } catch (...) {
5314       {
5315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5316       };
5317     }
5318   }
5319
5320   jresult = (void *)result;
5321   return jresult;
5322 }
5323
5324
5325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5326   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5327   float arg2 ;
5328
5329   arg1 = (Dali::Vector2 *)jarg1;
5330   arg2 = (float)jarg2;
5331   if (arg1) (arg1)->x = arg2;
5332 }
5333
5334
5335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5336   float jresult ;
5337   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5338   float result;
5339
5340   arg1 = (Dali::Vector2 *)jarg1;
5341   result = (float) ((arg1)->x);
5342   jresult = result;
5343   return jresult;
5344 }
5345
5346
5347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5348   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5349   float arg2 ;
5350
5351   arg1 = (Dali::Vector2 *)jarg1;
5352   arg2 = (float)jarg2;
5353   if (arg1) (arg1)->width = arg2;
5354 }
5355
5356
5357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5358   float jresult ;
5359   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5360   float result;
5361
5362   arg1 = (Dali::Vector2 *)jarg1;
5363   result = (float) ((arg1)->width);
5364   jresult = result;
5365   return jresult;
5366 }
5367
5368
5369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5370   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5371   float arg2 ;
5372
5373   arg1 = (Dali::Vector2 *)jarg1;
5374   arg2 = (float)jarg2;
5375   if (arg1) (arg1)->y = arg2;
5376 }
5377
5378
5379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5380   float jresult ;
5381   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5382   float result;
5383
5384   arg1 = (Dali::Vector2 *)jarg1;
5385   result = (float) ((arg1)->y);
5386   jresult = result;
5387   return jresult;
5388 }
5389
5390
5391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5392   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5393   float arg2 ;
5394
5395   arg1 = (Dali::Vector2 *)jarg1;
5396   arg2 = (float)jarg2;
5397   if (arg1) (arg1)->height = arg2;
5398 }
5399
5400
5401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5402   float jresult ;
5403   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5404   float result;
5405
5406   arg1 = (Dali::Vector2 *)jarg1;
5407   result = (float) ((arg1)->height);
5408   jresult = result;
5409   return jresult;
5410 }
5411
5412
5413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5414   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5415
5416   arg1 = (Dali::Vector2 *)jarg1;
5417   {
5418     try {
5419       delete arg1;
5420     } catch (std::out_of_range& e) {
5421       {
5422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5423       };
5424     } catch (std::exception& e) {
5425       {
5426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5427       };
5428     } catch (Dali::DaliException e) {
5429       {
5430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5431       };
5432     } catch (...) {
5433       {
5434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5435       };
5436     }
5437   }
5438
5439 }
5440
5441
5442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5443   void * jresult ;
5444   Dali::Vector2 *arg1 = 0 ;
5445   Dali::Vector2 *arg2 = 0 ;
5446   Dali::Vector2 result;
5447
5448   arg1 = (Dali::Vector2 *)jarg1;
5449   if (!arg1) {
5450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5451     return 0;
5452   }
5453   arg2 = (Dali::Vector2 *)jarg2;
5454   if (!arg2) {
5455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5456     return 0;
5457   }
5458   {
5459     try {
5460       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5461     } catch (std::out_of_range& e) {
5462       {
5463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5464       };
5465     } catch (std::exception& e) {
5466       {
5467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5468       };
5469     } catch (Dali::DaliException e) {
5470       {
5471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5472       };
5473     } catch (...) {
5474       {
5475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5476       };
5477     }
5478   }
5479
5480   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5481   return jresult;
5482 }
5483
5484
5485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5486   void * jresult ;
5487   Dali::Vector2 *arg1 = 0 ;
5488   Dali::Vector2 *arg2 = 0 ;
5489   Dali::Vector2 result;
5490
5491   arg1 = (Dali::Vector2 *)jarg1;
5492   if (!arg1) {
5493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5494     return 0;
5495   }
5496   arg2 = (Dali::Vector2 *)jarg2;
5497   if (!arg2) {
5498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5499     return 0;
5500   }
5501   {
5502     try {
5503       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5504     } catch (std::out_of_range& e) {
5505       {
5506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5507       };
5508     } catch (std::exception& e) {
5509       {
5510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5511       };
5512     } catch (Dali::DaliException e) {
5513       {
5514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5515       };
5516     } catch (...) {
5517       {
5518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5519       };
5520     }
5521   }
5522
5523   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5524   return jresult;
5525 }
5526
5527
5528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5529   void * jresult ;
5530   Dali::Vector2 *arg1 = 0 ;
5531   float *arg2 = 0 ;
5532   float *arg3 = 0 ;
5533   float temp2 ;
5534   float temp3 ;
5535   Dali::Vector2 result;
5536
5537   arg1 = (Dali::Vector2 *)jarg1;
5538   if (!arg1) {
5539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5540     return 0;
5541   }
5542   temp2 = (float)jarg2;
5543   arg2 = &temp2;
5544   temp3 = (float)jarg3;
5545   arg3 = &temp3;
5546   {
5547     try {
5548       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5549     } catch (std::out_of_range& e) {
5550       {
5551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5552       };
5553     } catch (std::exception& e) {
5554       {
5555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5556       };
5557     } catch (Dali::DaliException e) {
5558       {
5559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5560       };
5561     } catch (...) {
5562       {
5563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5564       };
5565     }
5566   }
5567
5568   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5569   return jresult;
5570 }
5571
5572
5573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5574   void * jresult ;
5575   Dali::Vector3 *result = 0 ;
5576
5577   {
5578     try {
5579       result = (Dali::Vector3 *)new Dali::Vector3();
5580     } catch (std::out_of_range& e) {
5581       {
5582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5583       };
5584     } catch (std::exception& e) {
5585       {
5586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5587       };
5588     } catch (Dali::DaliException e) {
5589       {
5590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5591       };
5592     } catch (...) {
5593       {
5594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5595       };
5596     }
5597   }
5598
5599   jresult = (void *)result;
5600   return jresult;
5601 }
5602
5603
5604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5605   void * jresult ;
5606   float arg1 ;
5607   float arg2 ;
5608   float arg3 ;
5609   Dali::Vector3 *result = 0 ;
5610
5611   arg1 = (float)jarg1;
5612   arg2 = (float)jarg2;
5613   arg3 = (float)jarg3;
5614   {
5615     try {
5616       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5617     } catch (std::out_of_range& e) {
5618       {
5619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5620       };
5621     } catch (std::exception& e) {
5622       {
5623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5624       };
5625     } catch (Dali::DaliException e) {
5626       {
5627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5628       };
5629     } catch (...) {
5630       {
5631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5632       };
5633     }
5634   }
5635
5636   jresult = (void *)result;
5637   return jresult;
5638 }
5639
5640
5641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5642   void * jresult ;
5643   float *arg1 = (float *) 0 ;
5644   Dali::Vector3 *result = 0 ;
5645
5646   arg1 = jarg1;
5647   {
5648     try {
5649       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5650     } catch (std::out_of_range& e) {
5651       {
5652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5653       };
5654     } catch (std::exception& e) {
5655       {
5656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5657       };
5658     } catch (Dali::DaliException e) {
5659       {
5660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5661       };
5662     } catch (...) {
5663       {
5664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5665       };
5666     }
5667   }
5668
5669   jresult = (void *)result;
5670
5671
5672   return jresult;
5673 }
5674
5675
5676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5677   void * jresult ;
5678   Dali::Vector2 *arg1 = 0 ;
5679   Dali::Vector3 *result = 0 ;
5680
5681   arg1 = (Dali::Vector2 *)jarg1;
5682   if (!arg1) {
5683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5684     return 0;
5685   }
5686   {
5687     try {
5688       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5689     } catch (std::out_of_range& e) {
5690       {
5691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5692       };
5693     } catch (std::exception& e) {
5694       {
5695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5696       };
5697     } catch (Dali::DaliException e) {
5698       {
5699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5700       };
5701     } catch (...) {
5702       {
5703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5704       };
5705     }
5706   }
5707
5708   jresult = (void *)result;
5709   return jresult;
5710 }
5711
5712
5713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5714   void * jresult ;
5715   Dali::Vector4 *arg1 = 0 ;
5716   Dali::Vector3 *result = 0 ;
5717
5718   arg1 = (Dali::Vector4 *)jarg1;
5719   if (!arg1) {
5720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5721     return 0;
5722   }
5723   {
5724     try {
5725       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5726     } catch (std::out_of_range& e) {
5727       {
5728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5729       };
5730     } catch (std::exception& e) {
5731       {
5732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5733       };
5734     } catch (Dali::DaliException e) {
5735       {
5736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5737       };
5738     } catch (...) {
5739       {
5740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5741       };
5742     }
5743   }
5744
5745   jresult = (void *)result;
5746   return jresult;
5747 }
5748
5749
5750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5751   void * jresult ;
5752   Dali::Vector3 *result = 0 ;
5753
5754   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5755   jresult = (void *)result;
5756   return jresult;
5757 }
5758
5759
5760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5761   void * jresult ;
5762   Dali::Vector3 *result = 0 ;
5763
5764   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5765   jresult = (void *)result;
5766   return jresult;
5767 }
5768
5769
5770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5771   void * jresult ;
5772   Dali::Vector3 *result = 0 ;
5773
5774   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5775   jresult = (void *)result;
5776   return jresult;
5777 }
5778
5779
5780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5781   void * jresult ;
5782   Dali::Vector3 *result = 0 ;
5783
5784   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5785   jresult = (void *)result;
5786   return jresult;
5787 }
5788
5789
5790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5791   void * jresult ;
5792   Dali::Vector3 *result = 0 ;
5793
5794   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5795   jresult = (void *)result;
5796   return jresult;
5797 }
5798
5799
5800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5801   void * jresult ;
5802   Dali::Vector3 *result = 0 ;
5803
5804   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5805   jresult = (void *)result;
5806   return jresult;
5807 }
5808
5809
5810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5811   void * jresult ;
5812   Dali::Vector3 *result = 0 ;
5813
5814   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5815   jresult = (void *)result;
5816   return jresult;
5817 }
5818
5819
5820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5821   void * jresult ;
5822   Dali::Vector3 *result = 0 ;
5823
5824   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5825   jresult = (void *)result;
5826   return jresult;
5827 }
5828
5829
5830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5831   void * jresult ;
5832   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5833   float *arg2 = (float *) 0 ;
5834   Dali::Vector3 *result = 0 ;
5835
5836   arg1 = (Dali::Vector3 *)jarg1;
5837   arg2 = jarg2;
5838   {
5839     try {
5840       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5841     } catch (std::out_of_range& e) {
5842       {
5843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5844       };
5845     } catch (std::exception& e) {
5846       {
5847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5848       };
5849     } catch (Dali::DaliException e) {
5850       {
5851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5852       };
5853     } catch (...) {
5854       {
5855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5856       };
5857     }
5858   }
5859
5860   jresult = (void *)result;
5861
5862
5863   return jresult;
5864 }
5865
5866
5867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5868   void * jresult ;
5869   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5870   Dali::Vector2 *arg2 = 0 ;
5871   Dali::Vector3 *result = 0 ;
5872
5873   arg1 = (Dali::Vector3 *)jarg1;
5874   arg2 = (Dali::Vector2 *)jarg2;
5875   if (!arg2) {
5876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5877     return 0;
5878   }
5879   {
5880     try {
5881       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5882     } catch (std::out_of_range& e) {
5883       {
5884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5885       };
5886     } catch (std::exception& e) {
5887       {
5888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5889       };
5890     } catch (Dali::DaliException e) {
5891       {
5892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5893       };
5894     } catch (...) {
5895       {
5896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5897       };
5898     }
5899   }
5900
5901   jresult = (void *)result;
5902   return jresult;
5903 }
5904
5905
5906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5907   void * jresult ;
5908   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5909   Dali::Vector4 *arg2 = 0 ;
5910   Dali::Vector3 *result = 0 ;
5911
5912   arg1 = (Dali::Vector3 *)jarg1;
5913   arg2 = (Dali::Vector4 *)jarg2;
5914   if (!arg2) {
5915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5916     return 0;
5917   }
5918   {
5919     try {
5920       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5921     } catch (std::out_of_range& e) {
5922       {
5923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5924       };
5925     } catch (std::exception& e) {
5926       {
5927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5928       };
5929     } catch (Dali::DaliException e) {
5930       {
5931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5932       };
5933     } catch (...) {
5934       {
5935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5936       };
5937     }
5938   }
5939
5940   jresult = (void *)result;
5941   return jresult;
5942 }
5943
5944
5945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5946   void * jresult ;
5947   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5948   Dali::Vector3 *arg2 = 0 ;
5949   Dali::Vector3 result;
5950
5951   arg1 = (Dali::Vector3 *)jarg1;
5952   arg2 = (Dali::Vector3 *)jarg2;
5953   if (!arg2) {
5954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5955     return 0;
5956   }
5957   {
5958     try {
5959       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5960     } catch (std::out_of_range& e) {
5961       {
5962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5963       };
5964     } catch (std::exception& e) {
5965       {
5966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5967       };
5968     } catch (Dali::DaliException e) {
5969       {
5970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5971       };
5972     } catch (...) {
5973       {
5974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5975       };
5976     }
5977   }
5978
5979   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5980   return jresult;
5981 }
5982
5983
5984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5985   void * jresult ;
5986   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5987   Dali::Vector3 *arg2 = 0 ;
5988   Dali::Vector3 *result = 0 ;
5989
5990   arg1 = (Dali::Vector3 *)jarg1;
5991   arg2 = (Dali::Vector3 *)jarg2;
5992   if (!arg2) {
5993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5994     return 0;
5995   }
5996   {
5997     try {
5998       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5999     } catch (std::out_of_range& e) {
6000       {
6001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6002       };
6003     } catch (std::exception& e) {
6004       {
6005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6006       };
6007     } catch (Dali::DaliException e) {
6008       {
6009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6010       };
6011     } catch (...) {
6012       {
6013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6014       };
6015     }
6016   }
6017
6018   jresult = (void *)result;
6019   return jresult;
6020 }
6021
6022
6023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6024   void * jresult ;
6025   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6026   Dali::Vector3 *arg2 = 0 ;
6027   Dali::Vector3 result;
6028
6029   arg1 = (Dali::Vector3 *)jarg1;
6030   arg2 = (Dali::Vector3 *)jarg2;
6031   if (!arg2) {
6032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6033     return 0;
6034   }
6035   {
6036     try {
6037       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6038     } catch (std::out_of_range& e) {
6039       {
6040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6041       };
6042     } catch (std::exception& e) {
6043       {
6044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6045       };
6046     } catch (Dali::DaliException e) {
6047       {
6048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6049       };
6050     } catch (...) {
6051       {
6052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6053       };
6054     }
6055   }
6056
6057   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6058   return jresult;
6059 }
6060
6061
6062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6063   void * jresult ;
6064   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6065   Dali::Vector3 *arg2 = 0 ;
6066   Dali::Vector3 *result = 0 ;
6067
6068   arg1 = (Dali::Vector3 *)jarg1;
6069   arg2 = (Dali::Vector3 *)jarg2;
6070   if (!arg2) {
6071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6072     return 0;
6073   }
6074   {
6075     try {
6076       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6077     } catch (std::out_of_range& e) {
6078       {
6079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6080       };
6081     } catch (std::exception& e) {
6082       {
6083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6084       };
6085     } catch (Dali::DaliException e) {
6086       {
6087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6088       };
6089     } catch (...) {
6090       {
6091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6092       };
6093     }
6094   }
6095
6096   jresult = (void *)result;
6097   return jresult;
6098 }
6099
6100
6101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6102   void * jresult ;
6103   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6104   Dali::Vector3 *arg2 = 0 ;
6105   Dali::Vector3 result;
6106
6107   arg1 = (Dali::Vector3 *)jarg1;
6108   arg2 = (Dali::Vector3 *)jarg2;
6109   if (!arg2) {
6110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6111     return 0;
6112   }
6113   {
6114     try {
6115       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6116     } catch (std::out_of_range& e) {
6117       {
6118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6119       };
6120     } catch (std::exception& e) {
6121       {
6122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6123       };
6124     } catch (Dali::DaliException e) {
6125       {
6126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6127       };
6128     } catch (...) {
6129       {
6130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6131       };
6132     }
6133   }
6134
6135   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6136   return jresult;
6137 }
6138
6139
6140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6141   void * jresult ;
6142   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6143   float arg2 ;
6144   Dali::Vector3 result;
6145
6146   arg1 = (Dali::Vector3 *)jarg1;
6147   arg2 = (float)jarg2;
6148   {
6149     try {
6150       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6151     } catch (std::out_of_range& e) {
6152       {
6153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6154       };
6155     } catch (std::exception& e) {
6156       {
6157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6158       };
6159     } catch (Dali::DaliException e) {
6160       {
6161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6162       };
6163     } catch (...) {
6164       {
6165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6166       };
6167     }
6168   }
6169
6170   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6171   return jresult;
6172 }
6173
6174
6175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6176   void * jresult ;
6177   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6178   Dali::Vector3 *arg2 = 0 ;
6179   Dali::Vector3 *result = 0 ;
6180
6181   arg1 = (Dali::Vector3 *)jarg1;
6182   arg2 = (Dali::Vector3 *)jarg2;
6183   if (!arg2) {
6184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6185     return 0;
6186   }
6187   {
6188     try {
6189       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6190     } catch (std::out_of_range& e) {
6191       {
6192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6193       };
6194     } catch (std::exception& e) {
6195       {
6196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6197       };
6198     } catch (Dali::DaliException e) {
6199       {
6200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6201       };
6202     } catch (...) {
6203       {
6204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6205       };
6206     }
6207   }
6208
6209   jresult = (void *)result;
6210   return jresult;
6211 }
6212
6213
6214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6215   void * jresult ;
6216   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6217   float arg2 ;
6218   Dali::Vector3 *result = 0 ;
6219
6220   arg1 = (Dali::Vector3 *)jarg1;
6221   arg2 = (float)jarg2;
6222   {
6223     try {
6224       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6225     } catch (std::out_of_range& e) {
6226       {
6227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6228       };
6229     } catch (std::exception& e) {
6230       {
6231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6232       };
6233     } catch (Dali::DaliException e) {
6234       {
6235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6236       };
6237     } catch (...) {
6238       {
6239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6240       };
6241     }
6242   }
6243
6244   jresult = (void *)result;
6245   return jresult;
6246 }
6247
6248
6249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6250   void * jresult ;
6251   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6252   Dali::Quaternion *arg2 = 0 ;
6253   Dali::Vector3 *result = 0 ;
6254
6255   arg1 = (Dali::Vector3 *)jarg1;
6256   arg2 = (Dali::Quaternion *)jarg2;
6257   if (!arg2) {
6258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6259     return 0;
6260   }
6261   {
6262     try {
6263       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6264     } catch (std::out_of_range& e) {
6265       {
6266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6267       };
6268     } catch (std::exception& e) {
6269       {
6270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6271       };
6272     } catch (Dali::DaliException e) {
6273       {
6274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6275       };
6276     } catch (...) {
6277       {
6278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6279       };
6280     }
6281   }
6282
6283   jresult = (void *)result;
6284   return jresult;
6285 }
6286
6287
6288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6289   void * jresult ;
6290   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6291   Dali::Vector3 *arg2 = 0 ;
6292   Dali::Vector3 result;
6293
6294   arg1 = (Dali::Vector3 *)jarg1;
6295   arg2 = (Dali::Vector3 *)jarg2;
6296   if (!arg2) {
6297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6298     return 0;
6299   }
6300   {
6301     try {
6302       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6303     } catch (std::out_of_range& e) {
6304       {
6305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6306       };
6307     } catch (std::exception& e) {
6308       {
6309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6310       };
6311     } catch (Dali::DaliException e) {
6312       {
6313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6314       };
6315     } catch (...) {
6316       {
6317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6318       };
6319     }
6320   }
6321
6322   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6323   return jresult;
6324 }
6325
6326
6327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6328   void * jresult ;
6329   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6330   float arg2 ;
6331   Dali::Vector3 result;
6332
6333   arg1 = (Dali::Vector3 *)jarg1;
6334   arg2 = (float)jarg2;
6335   {
6336     try {
6337       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6338     } catch (std::out_of_range& e) {
6339       {
6340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6341       };
6342     } catch (std::exception& e) {
6343       {
6344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6345       };
6346     } catch (Dali::DaliException e) {
6347       {
6348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6349       };
6350     } catch (...) {
6351       {
6352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6353       };
6354     }
6355   }
6356
6357   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6358   return jresult;
6359 }
6360
6361
6362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6363   void * jresult ;
6364   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6365   Dali::Vector3 *arg2 = 0 ;
6366   Dali::Vector3 *result = 0 ;
6367
6368   arg1 = (Dali::Vector3 *)jarg1;
6369   arg2 = (Dali::Vector3 *)jarg2;
6370   if (!arg2) {
6371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6372     return 0;
6373   }
6374   {
6375     try {
6376       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6377     } catch (std::out_of_range& e) {
6378       {
6379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6380       };
6381     } catch (std::exception& e) {
6382       {
6383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6384       };
6385     } catch (Dali::DaliException e) {
6386       {
6387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6388       };
6389     } catch (...) {
6390       {
6391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6392       };
6393     }
6394   }
6395
6396   jresult = (void *)result;
6397   return jresult;
6398 }
6399
6400
6401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6402   void * jresult ;
6403   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6404   float arg2 ;
6405   Dali::Vector3 *result = 0 ;
6406
6407   arg1 = (Dali::Vector3 *)jarg1;
6408   arg2 = (float)jarg2;
6409   {
6410     try {
6411       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6412     } catch (std::out_of_range& e) {
6413       {
6414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6415       };
6416     } catch (std::exception& e) {
6417       {
6418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6419       };
6420     } catch (Dali::DaliException e) {
6421       {
6422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6423       };
6424     } catch (...) {
6425       {
6426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6427       };
6428     }
6429   }
6430
6431   jresult = (void *)result;
6432   return jresult;
6433 }
6434
6435
6436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6437   void * jresult ;
6438   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6439   Dali::Vector3 result;
6440
6441   arg1 = (Dali::Vector3 *)jarg1;
6442   {
6443     try {
6444       result = ((Dali::Vector3 const *)arg1)->operator -();
6445     } catch (std::out_of_range& e) {
6446       {
6447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6448       };
6449     } catch (std::exception& e) {
6450       {
6451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6452       };
6453     } catch (Dali::DaliException e) {
6454       {
6455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6456       };
6457     } catch (...) {
6458       {
6459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6460       };
6461     }
6462   }
6463
6464   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6465   return jresult;
6466 }
6467
6468
6469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6470   unsigned int jresult ;
6471   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6472   Dali::Vector3 *arg2 = 0 ;
6473   bool result;
6474
6475   arg1 = (Dali::Vector3 *)jarg1;
6476   arg2 = (Dali::Vector3 *)jarg2;
6477   if (!arg2) {
6478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6479     return 0;
6480   }
6481   {
6482     try {
6483       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6484     } catch (std::out_of_range& e) {
6485       {
6486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6487       };
6488     } catch (std::exception& e) {
6489       {
6490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6491       };
6492     } catch (Dali::DaliException e) {
6493       {
6494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6495       };
6496     } catch (...) {
6497       {
6498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6499       };
6500     }
6501   }
6502
6503   jresult = result;
6504   return jresult;
6505 }
6506
6507
6508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6509   unsigned int jresult ;
6510   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6511   Dali::Vector3 *arg2 = 0 ;
6512   bool result;
6513
6514   arg1 = (Dali::Vector3 *)jarg1;
6515   arg2 = (Dali::Vector3 *)jarg2;
6516   if (!arg2) {
6517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6518     return 0;
6519   }
6520   {
6521     try {
6522       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6523     } catch (std::out_of_range& e) {
6524       {
6525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6526       };
6527     } catch (std::exception& e) {
6528       {
6529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6530       };
6531     } catch (Dali::DaliException e) {
6532       {
6533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6534       };
6535     } catch (...) {
6536       {
6537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6538       };
6539     }
6540   }
6541
6542   jresult = result;
6543   return jresult;
6544 }
6545
6546
6547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6548   float jresult ;
6549   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6550   unsigned int arg2 ;
6551   float *result = 0 ;
6552
6553   arg1 = (Dali::Vector3 *)jarg1;
6554   arg2 = (unsigned int)jarg2;
6555   {
6556     try {
6557       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6558     } catch (std::out_of_range& e) {
6559       {
6560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6561       };
6562     } catch (std::exception& e) {
6563       {
6564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6565       };
6566     } catch (Dali::DaliException e) {
6567       {
6568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6569       };
6570     } catch (...) {
6571       {
6572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6573       };
6574     }
6575   }
6576
6577   jresult = *result;
6578   return jresult;
6579 }
6580
6581
6582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6583   float jresult ;
6584   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6585   Dali::Vector3 *arg2 = 0 ;
6586   float result;
6587
6588   arg1 = (Dali::Vector3 *)jarg1;
6589   arg2 = (Dali::Vector3 *)jarg2;
6590   if (!arg2) {
6591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6592     return 0;
6593   }
6594   {
6595     try {
6596       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6597     } catch (std::out_of_range& e) {
6598       {
6599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6600       };
6601     } catch (std::exception& e) {
6602       {
6603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6604       };
6605     } catch (Dali::DaliException e) {
6606       {
6607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6608       };
6609     } catch (...) {
6610       {
6611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6612       };
6613     }
6614   }
6615
6616   jresult = result;
6617   return jresult;
6618 }
6619
6620
6621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6622   void * jresult ;
6623   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6624   Dali::Vector3 *arg2 = 0 ;
6625   Dali::Vector3 result;
6626
6627   arg1 = (Dali::Vector3 *)jarg1;
6628   arg2 = (Dali::Vector3 *)jarg2;
6629   if (!arg2) {
6630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6631     return 0;
6632   }
6633   {
6634     try {
6635       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6636     } catch (std::out_of_range& e) {
6637       {
6638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6639       };
6640     } catch (std::exception& e) {
6641       {
6642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6643       };
6644     } catch (Dali::DaliException e) {
6645       {
6646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6647       };
6648     } catch (...) {
6649       {
6650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6651       };
6652     }
6653   }
6654
6655   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6656   return jresult;
6657 }
6658
6659
6660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6661   float jresult ;
6662   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6663   float result;
6664
6665   arg1 = (Dali::Vector3 *)jarg1;
6666   {
6667     try {
6668       result = (float)((Dali::Vector3 const *)arg1)->Length();
6669     } catch (std::out_of_range& e) {
6670       {
6671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6672       };
6673     } catch (std::exception& e) {
6674       {
6675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6676       };
6677     } catch (Dali::DaliException e) {
6678       {
6679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6680       };
6681     } catch (...) {
6682       {
6683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6684       };
6685     }
6686   }
6687
6688   jresult = result;
6689   return jresult;
6690 }
6691
6692
6693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6694   float jresult ;
6695   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6696   float result;
6697
6698   arg1 = (Dali::Vector3 *)jarg1;
6699   {
6700     try {
6701       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6702     } catch (std::out_of_range& e) {
6703       {
6704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6705       };
6706     } catch (std::exception& e) {
6707       {
6708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6709       };
6710     } catch (Dali::DaliException e) {
6711       {
6712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6713       };
6714     } catch (...) {
6715       {
6716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6717       };
6718     }
6719   }
6720
6721   jresult = result;
6722   return jresult;
6723 }
6724
6725
6726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6727   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6728
6729   arg1 = (Dali::Vector3 *)jarg1;
6730   {
6731     try {
6732       (arg1)->Normalize();
6733     } catch (std::out_of_range& e) {
6734       {
6735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6736       };
6737     } catch (std::exception& e) {
6738       {
6739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6740       };
6741     } catch (Dali::DaliException e) {
6742       {
6743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6744       };
6745     } catch (...) {
6746       {
6747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6748       };
6749     }
6750   }
6751
6752 }
6753
6754
6755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6756   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6757   Dali::Vector3 *arg2 = 0 ;
6758   Dali::Vector3 *arg3 = 0 ;
6759
6760   arg1 = (Dali::Vector3 *)jarg1;
6761   arg2 = (Dali::Vector3 *)jarg2;
6762   if (!arg2) {
6763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6764     return ;
6765   }
6766   arg3 = (Dali::Vector3 *)jarg3;
6767   if (!arg3) {
6768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6769     return ;
6770   }
6771   {
6772     try {
6773       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6774     } catch (std::out_of_range& e) {
6775       {
6776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6777       };
6778     } catch (std::exception& e) {
6779       {
6780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6781       };
6782     } catch (Dali::DaliException e) {
6783       {
6784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6785       };
6786     } catch (...) {
6787       {
6788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6789       };
6790     }
6791   }
6792
6793 }
6794
6795
6796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6797   void * jresult ;
6798   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6799   float *result = 0 ;
6800
6801   arg1 = (Dali::Vector3 *)jarg1;
6802   {
6803     try {
6804       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6805     } catch (std::out_of_range& e) {
6806       {
6807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6808       };
6809     } catch (std::exception& e) {
6810       {
6811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6812       };
6813     } catch (Dali::DaliException e) {
6814       {
6815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6816       };
6817     } catch (...) {
6818       {
6819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6820       };
6821     }
6822   }
6823
6824   jresult = (void *)result;
6825   return jresult;
6826 }
6827
6828
6829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6830   void * jresult ;
6831   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6832   Dali::Vector2 *result = 0 ;
6833
6834   arg1 = (Dali::Vector3 *)jarg1;
6835   {
6836     try {
6837       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6838     } catch (std::out_of_range& e) {
6839       {
6840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6841       };
6842     } catch (std::exception& e) {
6843       {
6844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6845       };
6846     } catch (Dali::DaliException e) {
6847       {
6848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6849       };
6850     } catch (...) {
6851       {
6852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6853       };
6854     }
6855   }
6856
6857   jresult = (void *)result;
6858   return jresult;
6859 }
6860
6861
6862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6863   void * jresult ;
6864   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6865   Dali::Vector2 *result = 0 ;
6866
6867   arg1 = (Dali::Vector3 *)jarg1;
6868   {
6869     try {
6870       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6871     } catch (std::out_of_range& e) {
6872       {
6873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6874       };
6875     } catch (std::exception& e) {
6876       {
6877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6878       };
6879     } catch (Dali::DaliException e) {
6880       {
6881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6882       };
6883     } catch (...) {
6884       {
6885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6886       };
6887     }
6888   }
6889
6890   jresult = (void *)result;
6891   return jresult;
6892 }
6893
6894
6895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6896   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6897   float arg2 ;
6898
6899   arg1 = (Dali::Vector3 *)jarg1;
6900   arg2 = (float)jarg2;
6901   if (arg1) (arg1)->x = arg2;
6902 }
6903
6904
6905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6906   float jresult ;
6907   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6908   float result;
6909
6910   arg1 = (Dali::Vector3 *)jarg1;
6911   result = (float) ((arg1)->x);
6912   jresult = result;
6913   return jresult;
6914 }
6915
6916
6917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6918   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6919   float arg2 ;
6920
6921   arg1 = (Dali::Vector3 *)jarg1;
6922   arg2 = (float)jarg2;
6923   if (arg1) (arg1)->width = arg2;
6924 }
6925
6926
6927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6928   float jresult ;
6929   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6930   float result;
6931
6932   arg1 = (Dali::Vector3 *)jarg1;
6933   result = (float) ((arg1)->width);
6934   jresult = result;
6935   return jresult;
6936 }
6937
6938
6939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6940   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6941   float arg2 ;
6942
6943   arg1 = (Dali::Vector3 *)jarg1;
6944   arg2 = (float)jarg2;
6945   if (arg1) (arg1)->r = arg2;
6946 }
6947
6948
6949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6950   float jresult ;
6951   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6952   float result;
6953
6954   arg1 = (Dali::Vector3 *)jarg1;
6955   result = (float) ((arg1)->r);
6956   jresult = result;
6957   return jresult;
6958 }
6959
6960
6961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6962   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6963   float arg2 ;
6964
6965   arg1 = (Dali::Vector3 *)jarg1;
6966   arg2 = (float)jarg2;
6967   if (arg1) (arg1)->y = arg2;
6968 }
6969
6970
6971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6972   float jresult ;
6973   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6974   float result;
6975
6976   arg1 = (Dali::Vector3 *)jarg1;
6977   result = (float) ((arg1)->y);
6978   jresult = result;
6979   return jresult;
6980 }
6981
6982
6983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6984   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6985   float arg2 ;
6986
6987   arg1 = (Dali::Vector3 *)jarg1;
6988   arg2 = (float)jarg2;
6989   if (arg1) (arg1)->height = arg2;
6990 }
6991
6992
6993 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6994   float jresult ;
6995   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6996   float result;
6997
6998   arg1 = (Dali::Vector3 *)jarg1;
6999   result = (float) ((arg1)->height);
7000   jresult = result;
7001   return jresult;
7002 }
7003
7004
7005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7006   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7007   float arg2 ;
7008
7009   arg1 = (Dali::Vector3 *)jarg1;
7010   arg2 = (float)jarg2;
7011   if (arg1) (arg1)->g = arg2;
7012 }
7013
7014
7015 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7016   float jresult ;
7017   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7018   float result;
7019
7020   arg1 = (Dali::Vector3 *)jarg1;
7021   result = (float) ((arg1)->g);
7022   jresult = result;
7023   return jresult;
7024 }
7025
7026
7027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7028   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7029   float arg2 ;
7030
7031   arg1 = (Dali::Vector3 *)jarg1;
7032   arg2 = (float)jarg2;
7033   if (arg1) (arg1)->z = arg2;
7034 }
7035
7036
7037 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7038   float jresult ;
7039   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7040   float result;
7041
7042   arg1 = (Dali::Vector3 *)jarg1;
7043   result = (float) ((arg1)->z);
7044   jresult = result;
7045   return jresult;
7046 }
7047
7048
7049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7050   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7051   float arg2 ;
7052
7053   arg1 = (Dali::Vector3 *)jarg1;
7054   arg2 = (float)jarg2;
7055   if (arg1) (arg1)->depth = arg2;
7056 }
7057
7058
7059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7060   float jresult ;
7061   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7062   float result;
7063
7064   arg1 = (Dali::Vector3 *)jarg1;
7065   result = (float) ((arg1)->depth);
7066   jresult = result;
7067   return jresult;
7068 }
7069
7070
7071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7072   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7073   float arg2 ;
7074
7075   arg1 = (Dali::Vector3 *)jarg1;
7076   arg2 = (float)jarg2;
7077   if (arg1) (arg1)->b = arg2;
7078 }
7079
7080
7081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7082   float jresult ;
7083   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7084   float result;
7085
7086   arg1 = (Dali::Vector3 *)jarg1;
7087   result = (float) ((arg1)->b);
7088   jresult = result;
7089   return jresult;
7090 }
7091
7092
7093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7094   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7095
7096   arg1 = (Dali::Vector3 *)jarg1;
7097   {
7098     try {
7099       delete arg1;
7100     } catch (std::out_of_range& e) {
7101       {
7102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7103       };
7104     } catch (std::exception& e) {
7105       {
7106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7107       };
7108     } catch (Dali::DaliException e) {
7109       {
7110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7111       };
7112     } catch (...) {
7113       {
7114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7115       };
7116     }
7117   }
7118
7119 }
7120
7121
7122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7123   void * jresult ;
7124   Dali::Vector3 *arg1 = 0 ;
7125   Dali::Vector3 *arg2 = 0 ;
7126   Dali::Vector3 result;
7127
7128   arg1 = (Dali::Vector3 *)jarg1;
7129   if (!arg1) {
7130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7131     return 0;
7132   }
7133   arg2 = (Dali::Vector3 *)jarg2;
7134   if (!arg2) {
7135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7136     return 0;
7137   }
7138   {
7139     try {
7140       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7141     } catch (std::out_of_range& e) {
7142       {
7143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7144       };
7145     } catch (std::exception& e) {
7146       {
7147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7148       };
7149     } catch (Dali::DaliException e) {
7150       {
7151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7152       };
7153     } catch (...) {
7154       {
7155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7156       };
7157     }
7158   }
7159
7160   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7161   return jresult;
7162 }
7163
7164
7165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7166   void * jresult ;
7167   Dali::Vector3 *arg1 = 0 ;
7168   Dali::Vector3 *arg2 = 0 ;
7169   Dali::Vector3 result;
7170
7171   arg1 = (Dali::Vector3 *)jarg1;
7172   if (!arg1) {
7173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7174     return 0;
7175   }
7176   arg2 = (Dali::Vector3 *)jarg2;
7177   if (!arg2) {
7178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7179     return 0;
7180   }
7181   {
7182     try {
7183       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7184     } catch (std::out_of_range& e) {
7185       {
7186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7187       };
7188     } catch (std::exception& e) {
7189       {
7190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7191       };
7192     } catch (Dali::DaliException e) {
7193       {
7194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7195       };
7196     } catch (...) {
7197       {
7198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7199       };
7200     }
7201   }
7202
7203   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7204   return jresult;
7205 }
7206
7207
7208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7209   void * jresult ;
7210   Dali::Vector3 *arg1 = 0 ;
7211   float *arg2 = 0 ;
7212   float *arg3 = 0 ;
7213   float temp2 ;
7214   float temp3 ;
7215   Dali::Vector3 result;
7216
7217   arg1 = (Dali::Vector3 *)jarg1;
7218   if (!arg1) {
7219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7220     return 0;
7221   }
7222   temp2 = (float)jarg2;
7223   arg2 = &temp2;
7224   temp3 = (float)jarg3;
7225   arg3 = &temp3;
7226   {
7227     try {
7228       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7229     } catch (std::out_of_range& e) {
7230       {
7231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7232       };
7233     } catch (std::exception& e) {
7234       {
7235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7236       };
7237     } catch (Dali::DaliException e) {
7238       {
7239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7240       };
7241     } catch (...) {
7242       {
7243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7244       };
7245     }
7246   }
7247
7248   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7249   return jresult;
7250 }
7251
7252
7253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7254   void * jresult ;
7255   Dali::Vector4 *result = 0 ;
7256
7257   {
7258     try {
7259       result = (Dali::Vector4 *)new Dali::Vector4();
7260     } catch (std::out_of_range& e) {
7261       {
7262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7263       };
7264     } catch (std::exception& e) {
7265       {
7266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7267       };
7268     } catch (Dali::DaliException e) {
7269       {
7270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7271       };
7272     } catch (...) {
7273       {
7274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7275       };
7276     }
7277   }
7278
7279   jresult = (void *)result;
7280   return jresult;
7281 }
7282
7283
7284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7285   void * jresult ;
7286   float arg1 ;
7287   float arg2 ;
7288   float arg3 ;
7289   float arg4 ;
7290   Dali::Vector4 *result = 0 ;
7291
7292   arg1 = (float)jarg1;
7293   arg2 = (float)jarg2;
7294   arg3 = (float)jarg3;
7295   arg4 = (float)jarg4;
7296   {
7297     try {
7298       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7299     } catch (std::out_of_range& e) {
7300       {
7301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7302       };
7303     } catch (std::exception& e) {
7304       {
7305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7306       };
7307     } catch (Dali::DaliException e) {
7308       {
7309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7310       };
7311     } catch (...) {
7312       {
7313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7314       };
7315     }
7316   }
7317
7318   jresult = (void *)result;
7319   return jresult;
7320 }
7321
7322
7323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7324   void * jresult ;
7325   float *arg1 = (float *) 0 ;
7326   Dali::Vector4 *result = 0 ;
7327
7328   arg1 = jarg1;
7329   {
7330     try {
7331       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7332     } catch (std::out_of_range& e) {
7333       {
7334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7335       };
7336     } catch (std::exception& e) {
7337       {
7338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7339       };
7340     } catch (Dali::DaliException e) {
7341       {
7342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7343       };
7344     } catch (...) {
7345       {
7346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7347       };
7348     }
7349   }
7350
7351   jresult = (void *)result;
7352
7353
7354   return jresult;
7355 }
7356
7357
7358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7359   void * jresult ;
7360   Dali::Vector2 *arg1 = 0 ;
7361   Dali::Vector4 *result = 0 ;
7362
7363   arg1 = (Dali::Vector2 *)jarg1;
7364   if (!arg1) {
7365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7366     return 0;
7367   }
7368   {
7369     try {
7370       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7371     } catch (std::out_of_range& e) {
7372       {
7373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7374       };
7375     } catch (std::exception& e) {
7376       {
7377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7378       };
7379     } catch (Dali::DaliException e) {
7380       {
7381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7382       };
7383     } catch (...) {
7384       {
7385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7386       };
7387     }
7388   }
7389
7390   jresult = (void *)result;
7391   return jresult;
7392 }
7393
7394
7395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7396   void * jresult ;
7397   Dali::Vector3 *arg1 = 0 ;
7398   Dali::Vector4 *result = 0 ;
7399
7400   arg1 = (Dali::Vector3 *)jarg1;
7401   if (!arg1) {
7402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7403     return 0;
7404   }
7405   {
7406     try {
7407       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7408     } catch (std::out_of_range& e) {
7409       {
7410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7411       };
7412     } catch (std::exception& e) {
7413       {
7414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7415       };
7416     } catch (Dali::DaliException e) {
7417       {
7418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7419       };
7420     } catch (...) {
7421       {
7422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7423       };
7424     }
7425   }
7426
7427   jresult = (void *)result;
7428   return jresult;
7429 }
7430
7431
7432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7433   void * jresult ;
7434   Dali::Vector4 *result = 0 ;
7435
7436   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7437   jresult = (void *)result;
7438   return jresult;
7439 }
7440
7441
7442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7443   void * jresult ;
7444   Dali::Vector4 *result = 0 ;
7445
7446   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7447   jresult = (void *)result;
7448   return jresult;
7449 }
7450
7451
7452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7453   void * jresult ;
7454   Dali::Vector4 *result = 0 ;
7455
7456   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7457   jresult = (void *)result;
7458   return jresult;
7459 }
7460
7461
7462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7463   void * jresult ;
7464   Dali::Vector4 *result = 0 ;
7465
7466   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7467   jresult = (void *)result;
7468   return jresult;
7469 }
7470
7471
7472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7473   void * jresult ;
7474   Dali::Vector4 *result = 0 ;
7475
7476   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7477   jresult = (void *)result;
7478   return jresult;
7479 }
7480
7481
7482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7483   void * jresult ;
7484   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7485   float *arg2 = (float *) 0 ;
7486   Dali::Vector4 *result = 0 ;
7487
7488   arg1 = (Dali::Vector4 *)jarg1;
7489   arg2 = jarg2;
7490   {
7491     try {
7492       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7493     } catch (std::out_of_range& e) {
7494       {
7495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7496       };
7497     } catch (std::exception& e) {
7498       {
7499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7500       };
7501     } catch (Dali::DaliException e) {
7502       {
7503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7504       };
7505     } catch (...) {
7506       {
7507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7508       };
7509     }
7510   }
7511
7512   jresult = (void *)result;
7513
7514
7515   return jresult;
7516 }
7517
7518
7519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7520   void * jresult ;
7521   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7522   Dali::Vector2 *arg2 = 0 ;
7523   Dali::Vector4 *result = 0 ;
7524
7525   arg1 = (Dali::Vector4 *)jarg1;
7526   arg2 = (Dali::Vector2 *)jarg2;
7527   if (!arg2) {
7528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7529     return 0;
7530   }
7531   {
7532     try {
7533       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7534     } catch (std::out_of_range& e) {
7535       {
7536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7537       };
7538     } catch (std::exception& e) {
7539       {
7540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7541       };
7542     } catch (Dali::DaliException e) {
7543       {
7544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7545       };
7546     } catch (...) {
7547       {
7548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7549       };
7550     }
7551   }
7552
7553   jresult = (void *)result;
7554   return jresult;
7555 }
7556
7557
7558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7559   void * jresult ;
7560   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7561   Dali::Vector3 *arg2 = 0 ;
7562   Dali::Vector4 *result = 0 ;
7563
7564   arg1 = (Dali::Vector4 *)jarg1;
7565   arg2 = (Dali::Vector3 *)jarg2;
7566   if (!arg2) {
7567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7568     return 0;
7569   }
7570   {
7571     try {
7572       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7573     } catch (std::out_of_range& e) {
7574       {
7575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7576       };
7577     } catch (std::exception& e) {
7578       {
7579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7580       };
7581     } catch (Dali::DaliException e) {
7582       {
7583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7584       };
7585     } catch (...) {
7586       {
7587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7588       };
7589     }
7590   }
7591
7592   jresult = (void *)result;
7593   return jresult;
7594 }
7595
7596
7597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7598   void * jresult ;
7599   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7600   Dali::Vector4 *arg2 = 0 ;
7601   Dali::Vector4 result;
7602
7603   arg1 = (Dali::Vector4 *)jarg1;
7604   arg2 = (Dali::Vector4 *)jarg2;
7605   if (!arg2) {
7606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7607     return 0;
7608   }
7609   {
7610     try {
7611       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7612     } catch (std::out_of_range& e) {
7613       {
7614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7615       };
7616     } catch (std::exception& e) {
7617       {
7618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7619       };
7620     } catch (Dali::DaliException e) {
7621       {
7622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7623       };
7624     } catch (...) {
7625       {
7626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7627       };
7628     }
7629   }
7630
7631   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7632   return jresult;
7633 }
7634
7635
7636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7637   void * jresult ;
7638   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7639   Dali::Vector4 *arg2 = 0 ;
7640   Dali::Vector4 *result = 0 ;
7641
7642   arg1 = (Dali::Vector4 *)jarg1;
7643   arg2 = (Dali::Vector4 *)jarg2;
7644   if (!arg2) {
7645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7646     return 0;
7647   }
7648   {
7649     try {
7650       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7651     } catch (std::out_of_range& e) {
7652       {
7653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7654       };
7655     } catch (std::exception& e) {
7656       {
7657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7658       };
7659     } catch (Dali::DaliException e) {
7660       {
7661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7662       };
7663     } catch (...) {
7664       {
7665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7666       };
7667     }
7668   }
7669
7670   jresult = (void *)result;
7671   return jresult;
7672 }
7673
7674
7675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7676   void * jresult ;
7677   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7678   Dali::Vector4 *arg2 = 0 ;
7679   Dali::Vector4 result;
7680
7681   arg1 = (Dali::Vector4 *)jarg1;
7682   arg2 = (Dali::Vector4 *)jarg2;
7683   if (!arg2) {
7684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7685     return 0;
7686   }
7687   {
7688     try {
7689       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7690     } catch (std::out_of_range& e) {
7691       {
7692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7693       };
7694     } catch (std::exception& e) {
7695       {
7696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7697       };
7698     } catch (Dali::DaliException e) {
7699       {
7700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7701       };
7702     } catch (...) {
7703       {
7704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7705       };
7706     }
7707   }
7708
7709   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7710   return jresult;
7711 }
7712
7713
7714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7715   void * jresult ;
7716   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7717   Dali::Vector4 *arg2 = 0 ;
7718   Dali::Vector4 *result = 0 ;
7719
7720   arg1 = (Dali::Vector4 *)jarg1;
7721   arg2 = (Dali::Vector4 *)jarg2;
7722   if (!arg2) {
7723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7724     return 0;
7725   }
7726   {
7727     try {
7728       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7729     } catch (std::out_of_range& e) {
7730       {
7731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7732       };
7733     } catch (std::exception& e) {
7734       {
7735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7736       };
7737     } catch (Dali::DaliException e) {
7738       {
7739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7740       };
7741     } catch (...) {
7742       {
7743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7744       };
7745     }
7746   }
7747
7748   jresult = (void *)result;
7749   return jresult;
7750 }
7751
7752
7753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7754   void * jresult ;
7755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7756   Dali::Vector4 *arg2 = 0 ;
7757   Dali::Vector4 result;
7758
7759   arg1 = (Dali::Vector4 *)jarg1;
7760   arg2 = (Dali::Vector4 *)jarg2;
7761   if (!arg2) {
7762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7763     return 0;
7764   }
7765   {
7766     try {
7767       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7768     } catch (std::out_of_range& e) {
7769       {
7770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7771       };
7772     } catch (std::exception& e) {
7773       {
7774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7775       };
7776     } catch (Dali::DaliException e) {
7777       {
7778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7779       };
7780     } catch (...) {
7781       {
7782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7783       };
7784     }
7785   }
7786
7787   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7788   return jresult;
7789 }
7790
7791
7792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7793   void * jresult ;
7794   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7795   float arg2 ;
7796   Dali::Vector4 result;
7797
7798   arg1 = (Dali::Vector4 *)jarg1;
7799   arg2 = (float)jarg2;
7800   {
7801     try {
7802       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7803     } catch (std::out_of_range& e) {
7804       {
7805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7806       };
7807     } catch (std::exception& e) {
7808       {
7809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7810       };
7811     } catch (Dali::DaliException e) {
7812       {
7813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7814       };
7815     } catch (...) {
7816       {
7817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7818       };
7819     }
7820   }
7821
7822   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7823   return jresult;
7824 }
7825
7826
7827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7828   void * jresult ;
7829   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7830   Dali::Vector4 *arg2 = 0 ;
7831   Dali::Vector4 *result = 0 ;
7832
7833   arg1 = (Dali::Vector4 *)jarg1;
7834   arg2 = (Dali::Vector4 *)jarg2;
7835   if (!arg2) {
7836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7837     return 0;
7838   }
7839   {
7840     try {
7841       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7842     } catch (std::out_of_range& e) {
7843       {
7844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7845       };
7846     } catch (std::exception& e) {
7847       {
7848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7849       };
7850     } catch (Dali::DaliException e) {
7851       {
7852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7853       };
7854     } catch (...) {
7855       {
7856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7857       };
7858     }
7859   }
7860
7861   jresult = (void *)result;
7862   return jresult;
7863 }
7864
7865
7866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7867   void * jresult ;
7868   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7869   float arg2 ;
7870   Dali::Vector4 *result = 0 ;
7871
7872   arg1 = (Dali::Vector4 *)jarg1;
7873   arg2 = (float)jarg2;
7874   {
7875     try {
7876       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7877     } catch (std::out_of_range& e) {
7878       {
7879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7880       };
7881     } catch (std::exception& e) {
7882       {
7883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7884       };
7885     } catch (Dali::DaliException e) {
7886       {
7887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7888       };
7889     } catch (...) {
7890       {
7891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7892       };
7893     }
7894   }
7895
7896   jresult = (void *)result;
7897   return jresult;
7898 }
7899
7900
7901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7902   void * jresult ;
7903   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7904   Dali::Vector4 *arg2 = 0 ;
7905   Dali::Vector4 result;
7906
7907   arg1 = (Dali::Vector4 *)jarg1;
7908   arg2 = (Dali::Vector4 *)jarg2;
7909   if (!arg2) {
7910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7911     return 0;
7912   }
7913   {
7914     try {
7915       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7916     } catch (std::out_of_range& e) {
7917       {
7918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7919       };
7920     } catch (std::exception& e) {
7921       {
7922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7923       };
7924     } catch (Dali::DaliException e) {
7925       {
7926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7927       };
7928     } catch (...) {
7929       {
7930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7931       };
7932     }
7933   }
7934
7935   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7936   return jresult;
7937 }
7938
7939
7940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7941   void * jresult ;
7942   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7943   float arg2 ;
7944   Dali::Vector4 result;
7945
7946   arg1 = (Dali::Vector4 *)jarg1;
7947   arg2 = (float)jarg2;
7948   {
7949     try {
7950       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7951     } catch (std::out_of_range& e) {
7952       {
7953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7954       };
7955     } catch (std::exception& e) {
7956       {
7957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7958       };
7959     } catch (Dali::DaliException e) {
7960       {
7961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7962       };
7963     } catch (...) {
7964       {
7965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7966       };
7967     }
7968   }
7969
7970   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7971   return jresult;
7972 }
7973
7974
7975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7976   void * jresult ;
7977   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7978   Dali::Vector4 *arg2 = 0 ;
7979   Dali::Vector4 *result = 0 ;
7980
7981   arg1 = (Dali::Vector4 *)jarg1;
7982   arg2 = (Dali::Vector4 *)jarg2;
7983   if (!arg2) {
7984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7985     return 0;
7986   }
7987   {
7988     try {
7989       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7990     } catch (std::out_of_range& e) {
7991       {
7992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7993       };
7994     } catch (std::exception& e) {
7995       {
7996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7997       };
7998     } catch (Dali::DaliException e) {
7999       {
8000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8001       };
8002     } catch (...) {
8003       {
8004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8005       };
8006     }
8007   }
8008
8009   jresult = (void *)result;
8010   return jresult;
8011 }
8012
8013
8014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8015   void * jresult ;
8016   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8017   float arg2 ;
8018   Dali::Vector4 *result = 0 ;
8019
8020   arg1 = (Dali::Vector4 *)jarg1;
8021   arg2 = (float)jarg2;
8022   {
8023     try {
8024       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8025     } catch (std::out_of_range& e) {
8026       {
8027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8028       };
8029     } catch (std::exception& e) {
8030       {
8031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8032       };
8033     } catch (Dali::DaliException e) {
8034       {
8035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8036       };
8037     } catch (...) {
8038       {
8039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8040       };
8041     }
8042   }
8043
8044   jresult = (void *)result;
8045   return jresult;
8046 }
8047
8048
8049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8050   void * jresult ;
8051   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8052   Dali::Vector4 result;
8053
8054   arg1 = (Dali::Vector4 *)jarg1;
8055   {
8056     try {
8057       result = ((Dali::Vector4 const *)arg1)->operator -();
8058     } catch (std::out_of_range& e) {
8059       {
8060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8061       };
8062     } catch (std::exception& e) {
8063       {
8064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8065       };
8066     } catch (Dali::DaliException e) {
8067       {
8068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8069       };
8070     } catch (...) {
8071       {
8072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8073       };
8074     }
8075   }
8076
8077   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8078   return jresult;
8079 }
8080
8081
8082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8083   unsigned int jresult ;
8084   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8085   Dali::Vector4 *arg2 = 0 ;
8086   bool result;
8087
8088   arg1 = (Dali::Vector4 *)jarg1;
8089   arg2 = (Dali::Vector4 *)jarg2;
8090   if (!arg2) {
8091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8092     return 0;
8093   }
8094   {
8095     try {
8096       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8097     } catch (std::out_of_range& e) {
8098       {
8099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8100       };
8101     } catch (std::exception& e) {
8102       {
8103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8104       };
8105     } catch (Dali::DaliException e) {
8106       {
8107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8108       };
8109     } catch (...) {
8110       {
8111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8112       };
8113     }
8114   }
8115
8116   jresult = result;
8117   return jresult;
8118 }
8119
8120
8121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8122   unsigned int jresult ;
8123   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8124   Dali::Vector4 *arg2 = 0 ;
8125   bool result;
8126
8127   arg1 = (Dali::Vector4 *)jarg1;
8128   arg2 = (Dali::Vector4 *)jarg2;
8129   if (!arg2) {
8130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8131     return 0;
8132   }
8133   {
8134     try {
8135       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8136     } catch (std::out_of_range& e) {
8137       {
8138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8139       };
8140     } catch (std::exception& e) {
8141       {
8142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8143       };
8144     } catch (Dali::DaliException e) {
8145       {
8146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8147       };
8148     } catch (...) {
8149       {
8150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8151       };
8152     }
8153   }
8154
8155   jresult = result;
8156   return jresult;
8157 }
8158
8159
8160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8161   float jresult ;
8162   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8163   unsigned int arg2 ;
8164   float *result = 0 ;
8165
8166   arg1 = (Dali::Vector4 *)jarg1;
8167   arg2 = (unsigned int)jarg2;
8168   {
8169     try {
8170       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8171     } catch (std::out_of_range& e) {
8172       {
8173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8174       };
8175     } catch (std::exception& e) {
8176       {
8177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8178       };
8179     } catch (Dali::DaliException e) {
8180       {
8181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8182       };
8183     } catch (...) {
8184       {
8185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8186       };
8187     }
8188   }
8189
8190   jresult = *result;
8191   return jresult;
8192 }
8193
8194
8195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8196   float jresult ;
8197   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8198   Dali::Vector3 *arg2 = 0 ;
8199   float result;
8200
8201   arg1 = (Dali::Vector4 *)jarg1;
8202   arg2 = (Dali::Vector3 *)jarg2;
8203   if (!arg2) {
8204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8205     return 0;
8206   }
8207   {
8208     try {
8209       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8210     } catch (std::out_of_range& e) {
8211       {
8212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8213       };
8214     } catch (std::exception& e) {
8215       {
8216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8217       };
8218     } catch (Dali::DaliException e) {
8219       {
8220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8221       };
8222     } catch (...) {
8223       {
8224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8225       };
8226     }
8227   }
8228
8229   jresult = result;
8230   return jresult;
8231 }
8232
8233
8234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8235   float jresult ;
8236   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8237   Dali::Vector4 *arg2 = 0 ;
8238   float result;
8239
8240   arg1 = (Dali::Vector4 *)jarg1;
8241   arg2 = (Dali::Vector4 *)jarg2;
8242   if (!arg2) {
8243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8244     return 0;
8245   }
8246   {
8247     try {
8248       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8249     } catch (std::out_of_range& e) {
8250       {
8251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8252       };
8253     } catch (std::exception& e) {
8254       {
8255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8256       };
8257     } catch (Dali::DaliException e) {
8258       {
8259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8260       };
8261     } catch (...) {
8262       {
8263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8264       };
8265     }
8266   }
8267
8268   jresult = result;
8269   return jresult;
8270 }
8271
8272
8273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8274   float jresult ;
8275   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8276   Dali::Vector4 *arg2 = 0 ;
8277   float result;
8278
8279   arg1 = (Dali::Vector4 *)jarg1;
8280   arg2 = (Dali::Vector4 *)jarg2;
8281   if (!arg2) {
8282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8283     return 0;
8284   }
8285   {
8286     try {
8287       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8288     } catch (std::out_of_range& e) {
8289       {
8290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8291       };
8292     } catch (std::exception& e) {
8293       {
8294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8295       };
8296     } catch (Dali::DaliException e) {
8297       {
8298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8299       };
8300     } catch (...) {
8301       {
8302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8303       };
8304     }
8305   }
8306
8307   jresult = result;
8308   return jresult;
8309 }
8310
8311
8312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8313   void * jresult ;
8314   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8315   Dali::Vector4 *arg2 = 0 ;
8316   Dali::Vector4 result;
8317
8318   arg1 = (Dali::Vector4 *)jarg1;
8319   arg2 = (Dali::Vector4 *)jarg2;
8320   if (!arg2) {
8321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8322     return 0;
8323   }
8324   {
8325     try {
8326       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8327     } catch (std::out_of_range& e) {
8328       {
8329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8330       };
8331     } catch (std::exception& e) {
8332       {
8333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8334       };
8335     } catch (Dali::DaliException e) {
8336       {
8337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8338       };
8339     } catch (...) {
8340       {
8341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8342       };
8343     }
8344   }
8345
8346   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8347   return jresult;
8348 }
8349
8350
8351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8352   float jresult ;
8353   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8354   float result;
8355
8356   arg1 = (Dali::Vector4 *)jarg1;
8357   {
8358     try {
8359       result = (float)((Dali::Vector4 const *)arg1)->Length();
8360     } catch (std::out_of_range& e) {
8361       {
8362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8363       };
8364     } catch (std::exception& e) {
8365       {
8366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8367       };
8368     } catch (Dali::DaliException e) {
8369       {
8370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8371       };
8372     } catch (...) {
8373       {
8374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8375       };
8376     }
8377   }
8378
8379   jresult = result;
8380   return jresult;
8381 }
8382
8383
8384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8385   float jresult ;
8386   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8387   float result;
8388
8389   arg1 = (Dali::Vector4 *)jarg1;
8390   {
8391     try {
8392       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8393     } catch (std::out_of_range& e) {
8394       {
8395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8396       };
8397     } catch (std::exception& e) {
8398       {
8399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8400       };
8401     } catch (Dali::DaliException e) {
8402       {
8403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8404       };
8405     } catch (...) {
8406       {
8407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8408       };
8409     }
8410   }
8411
8412   jresult = result;
8413   return jresult;
8414 }
8415
8416
8417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8418   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8419
8420   arg1 = (Dali::Vector4 *)jarg1;
8421   {
8422     try {
8423       (arg1)->Normalize();
8424     } catch (std::out_of_range& e) {
8425       {
8426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8427       };
8428     } catch (std::exception& e) {
8429       {
8430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8431       };
8432     } catch (Dali::DaliException e) {
8433       {
8434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8435       };
8436     } catch (...) {
8437       {
8438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8439       };
8440     }
8441   }
8442
8443 }
8444
8445
8446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8447   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8448   Dali::Vector4 *arg2 = 0 ;
8449   Dali::Vector4 *arg3 = 0 ;
8450
8451   arg1 = (Dali::Vector4 *)jarg1;
8452   arg2 = (Dali::Vector4 *)jarg2;
8453   if (!arg2) {
8454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8455     return ;
8456   }
8457   arg3 = (Dali::Vector4 *)jarg3;
8458   if (!arg3) {
8459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8460     return ;
8461   }
8462   {
8463     try {
8464       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8465     } catch (std::out_of_range& e) {
8466       {
8467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8468       };
8469     } catch (std::exception& e) {
8470       {
8471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8472       };
8473     } catch (Dali::DaliException e) {
8474       {
8475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8476       };
8477     } catch (...) {
8478       {
8479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8480       };
8481     }
8482   }
8483
8484 }
8485
8486
8487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8488   void * jresult ;
8489   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8490   float *result = 0 ;
8491
8492   arg1 = (Dali::Vector4 *)jarg1;
8493   {
8494     try {
8495       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8496     } catch (std::out_of_range& e) {
8497       {
8498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8499       };
8500     } catch (std::exception& e) {
8501       {
8502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8503       };
8504     } catch (Dali::DaliException e) {
8505       {
8506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8507       };
8508     } catch (...) {
8509       {
8510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8511       };
8512     }
8513   }
8514
8515   jresult = (void *)result;
8516   return jresult;
8517 }
8518
8519
8520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8521   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8522   float arg2 ;
8523
8524   arg1 = (Dali::Vector4 *)jarg1;
8525   arg2 = (float)jarg2;
8526   if (arg1) (arg1)->x = arg2;
8527 }
8528
8529
8530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8531   float jresult ;
8532   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8533   float result;
8534
8535   arg1 = (Dali::Vector4 *)jarg1;
8536   result = (float) ((arg1)->x);
8537   jresult = result;
8538   return jresult;
8539 }
8540
8541
8542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8543   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8544   float arg2 ;
8545
8546   arg1 = (Dali::Vector4 *)jarg1;
8547   arg2 = (float)jarg2;
8548   if (arg1) (arg1)->r = arg2;
8549 }
8550
8551
8552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8553   float jresult ;
8554   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8555   float result;
8556
8557   arg1 = (Dali::Vector4 *)jarg1;
8558   result = (float) ((arg1)->r);
8559   jresult = result;
8560   return jresult;
8561 }
8562
8563
8564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8566   float arg2 ;
8567
8568   arg1 = (Dali::Vector4 *)jarg1;
8569   arg2 = (float)jarg2;
8570   if (arg1) (arg1)->s = arg2;
8571 }
8572
8573
8574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8575   float jresult ;
8576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8577   float result;
8578
8579   arg1 = (Dali::Vector4 *)jarg1;
8580   result = (float) ((arg1)->s);
8581   jresult = result;
8582   return jresult;
8583 }
8584
8585
8586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8587   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8588   float arg2 ;
8589
8590   arg1 = (Dali::Vector4 *)jarg1;
8591   arg2 = (float)jarg2;
8592   if (arg1) (arg1)->y = arg2;
8593 }
8594
8595
8596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8597   float jresult ;
8598   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8599   float result;
8600
8601   arg1 = (Dali::Vector4 *)jarg1;
8602   result = (float) ((arg1)->y);
8603   jresult = result;
8604   return jresult;
8605 }
8606
8607
8608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8609   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8610   float arg2 ;
8611
8612   arg1 = (Dali::Vector4 *)jarg1;
8613   arg2 = (float)jarg2;
8614   if (arg1) (arg1)->g = arg2;
8615 }
8616
8617
8618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8619   float jresult ;
8620   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8621   float result;
8622
8623   arg1 = (Dali::Vector4 *)jarg1;
8624   result = (float) ((arg1)->g);
8625   jresult = result;
8626   return jresult;
8627 }
8628
8629
8630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8631   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8632   float arg2 ;
8633
8634   arg1 = (Dali::Vector4 *)jarg1;
8635   arg2 = (float)jarg2;
8636   if (arg1) (arg1)->t = arg2;
8637 }
8638
8639
8640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8641   float jresult ;
8642   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8643   float result;
8644
8645   arg1 = (Dali::Vector4 *)jarg1;
8646   result = (float) ((arg1)->t);
8647   jresult = result;
8648   return jresult;
8649 }
8650
8651
8652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8654   float arg2 ;
8655
8656   arg1 = (Dali::Vector4 *)jarg1;
8657   arg2 = (float)jarg2;
8658   if (arg1) (arg1)->z = arg2;
8659 }
8660
8661
8662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8663   float jresult ;
8664   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8665   float result;
8666
8667   arg1 = (Dali::Vector4 *)jarg1;
8668   result = (float) ((arg1)->z);
8669   jresult = result;
8670   return jresult;
8671 }
8672
8673
8674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8675   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8676   float arg2 ;
8677
8678   arg1 = (Dali::Vector4 *)jarg1;
8679   arg2 = (float)jarg2;
8680   if (arg1) (arg1)->b = arg2;
8681 }
8682
8683
8684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8685   float jresult ;
8686   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8687   float result;
8688
8689   arg1 = (Dali::Vector4 *)jarg1;
8690   result = (float) ((arg1)->b);
8691   jresult = result;
8692   return jresult;
8693 }
8694
8695
8696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8697   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8698   float arg2 ;
8699
8700   arg1 = (Dali::Vector4 *)jarg1;
8701   arg2 = (float)jarg2;
8702   if (arg1) (arg1)->p = arg2;
8703 }
8704
8705
8706 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8707   float jresult ;
8708   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8709   float result;
8710
8711   arg1 = (Dali::Vector4 *)jarg1;
8712   result = (float) ((arg1)->p);
8713   jresult = result;
8714   return jresult;
8715 }
8716
8717
8718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8720   float arg2 ;
8721
8722   arg1 = (Dali::Vector4 *)jarg1;
8723   arg2 = (float)jarg2;
8724   if (arg1) (arg1)->w = arg2;
8725 }
8726
8727
8728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8729   float jresult ;
8730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8731   float result;
8732
8733   arg1 = (Dali::Vector4 *)jarg1;
8734   result = (float) ((arg1)->w);
8735   jresult = result;
8736   return jresult;
8737 }
8738
8739
8740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8741   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8742   float arg2 ;
8743
8744   arg1 = (Dali::Vector4 *)jarg1;
8745   arg2 = (float)jarg2;
8746   if (arg1) (arg1)->a = arg2;
8747 }
8748
8749
8750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8751   float jresult ;
8752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8753   float result;
8754
8755   arg1 = (Dali::Vector4 *)jarg1;
8756   result = (float) ((arg1)->a);
8757   jresult = result;
8758   return jresult;
8759 }
8760
8761
8762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8764   float arg2 ;
8765
8766   arg1 = (Dali::Vector4 *)jarg1;
8767   arg2 = (float)jarg2;
8768   if (arg1) (arg1)->q = arg2;
8769 }
8770
8771
8772 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8773   float jresult ;
8774   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8775   float result;
8776
8777   arg1 = (Dali::Vector4 *)jarg1;
8778   result = (float) ((arg1)->q);
8779   jresult = result;
8780   return jresult;
8781 }
8782
8783
8784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8785   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8786
8787   arg1 = (Dali::Vector4 *)jarg1;
8788   {
8789     try {
8790       delete arg1;
8791     } catch (std::out_of_range& e) {
8792       {
8793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8794       };
8795     } catch (std::exception& e) {
8796       {
8797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8798       };
8799     } catch (Dali::DaliException e) {
8800       {
8801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8802       };
8803     } catch (...) {
8804       {
8805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8806       };
8807     }
8808   }
8809
8810 }
8811
8812
8813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8814   void * jresult ;
8815   Dali::Vector4 *arg1 = 0 ;
8816   Dali::Vector4 *arg2 = 0 ;
8817   Dali::Vector4 result;
8818
8819   arg1 = (Dali::Vector4 *)jarg1;
8820   if (!arg1) {
8821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8822     return 0;
8823   }
8824   arg2 = (Dali::Vector4 *)jarg2;
8825   if (!arg2) {
8826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8827     return 0;
8828   }
8829   {
8830     try {
8831       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8832     } catch (std::out_of_range& e) {
8833       {
8834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8835       };
8836     } catch (std::exception& e) {
8837       {
8838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8839       };
8840     } catch (Dali::DaliException e) {
8841       {
8842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8843       };
8844     } catch (...) {
8845       {
8846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8847       };
8848     }
8849   }
8850
8851   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8852   return jresult;
8853 }
8854
8855
8856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8857   void * jresult ;
8858   Dali::Vector4 *arg1 = 0 ;
8859   Dali::Vector4 *arg2 = 0 ;
8860   Dali::Vector4 result;
8861
8862   arg1 = (Dali::Vector4 *)jarg1;
8863   if (!arg1) {
8864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8865     return 0;
8866   }
8867   arg2 = (Dali::Vector4 *)jarg2;
8868   if (!arg2) {
8869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8870     return 0;
8871   }
8872   {
8873     try {
8874       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8875     } catch (std::out_of_range& e) {
8876       {
8877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8878       };
8879     } catch (std::exception& e) {
8880       {
8881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8882       };
8883     } catch (Dali::DaliException e) {
8884       {
8885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8886       };
8887     } catch (...) {
8888       {
8889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8890       };
8891     }
8892   }
8893
8894   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8895   return jresult;
8896 }
8897
8898
8899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8900   void * jresult ;
8901   Dali::Vector4 *arg1 = 0 ;
8902   float *arg2 = 0 ;
8903   float *arg3 = 0 ;
8904   float temp2 ;
8905   float temp3 ;
8906   Dali::Vector4 result;
8907
8908   arg1 = (Dali::Vector4 *)jarg1;
8909   if (!arg1) {
8910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8911     return 0;
8912   }
8913   temp2 = (float)jarg2;
8914   arg2 = &temp2;
8915   temp3 = (float)jarg3;
8916   arg3 = &temp3;
8917   {
8918     try {
8919       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8920     } catch (std::out_of_range& e) {
8921       {
8922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8923       };
8924     } catch (std::exception& e) {
8925       {
8926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8927       };
8928     } catch (Dali::DaliException e) {
8929       {
8930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8931       };
8932     } catch (...) {
8933       {
8934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8935       };
8936     }
8937   }
8938
8939   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8940   return jresult;
8941 }
8942
8943
8944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8945   void * jresult ;
8946   Dali::Uint16Pair *result = 0 ;
8947
8948   {
8949     try {
8950       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8951     } catch (std::out_of_range& e) {
8952       {
8953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8954       };
8955     } catch (std::exception& e) {
8956       {
8957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8958       };
8959     } catch (Dali::DaliException e) {
8960       {
8961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8962       };
8963     } catch (...) {
8964       {
8965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8966       };
8967     }
8968   }
8969
8970   jresult = (void *)result;
8971   return jresult;
8972 }
8973
8974
8975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8976   void * jresult ;
8977   uint32_t arg1 ;
8978   uint32_t arg2 ;
8979   Dali::Uint16Pair *result = 0 ;
8980
8981   arg1 = (uint32_t)jarg1;
8982   arg2 = (uint32_t)jarg2;
8983   {
8984     try {
8985       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8986     } catch (std::out_of_range& e) {
8987       {
8988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8989       };
8990     } catch (std::exception& e) {
8991       {
8992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8993       };
8994     } catch (Dali::DaliException e) {
8995       {
8996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8997       };
8998     } catch (...) {
8999       {
9000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9001       };
9002     }
9003   }
9004
9005   jresult = (void *)result;
9006   return jresult;
9007 }
9008
9009
9010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9011   void * jresult ;
9012   Dali::Uint16Pair *arg1 = 0 ;
9013   Dali::Uint16Pair *result = 0 ;
9014
9015   arg1 = (Dali::Uint16Pair *)jarg1;
9016   if (!arg1) {
9017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9018     return 0;
9019   }
9020   {
9021     try {
9022       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9023     } catch (std::out_of_range& e) {
9024       {
9025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9026       };
9027     } catch (std::exception& e) {
9028       {
9029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9030       };
9031     } catch (Dali::DaliException e) {
9032       {
9033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9034       };
9035     } catch (...) {
9036       {
9037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9038       };
9039     }
9040   }
9041
9042   jresult = (void *)result;
9043   return jresult;
9044 }
9045
9046
9047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9048   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9049   uint16_t arg2 ;
9050
9051   arg1 = (Dali::Uint16Pair *)jarg1;
9052   arg2 = (uint16_t)jarg2;
9053   {
9054     try {
9055       (arg1)->SetWidth(arg2);
9056     } catch (std::out_of_range& e) {
9057       {
9058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9059       };
9060     } catch (std::exception& e) {
9061       {
9062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9063       };
9064     } catch (Dali::DaliException e) {
9065       {
9066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9067       };
9068     } catch (...) {
9069       {
9070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9071       };
9072     }
9073   }
9074
9075 }
9076
9077
9078 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9079   unsigned short jresult ;
9080   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9081   uint16_t result;
9082
9083   arg1 = (Dali::Uint16Pair *)jarg1;
9084   {
9085     try {
9086       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9087     } catch (std::out_of_range& e) {
9088       {
9089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9090       };
9091     } catch (std::exception& e) {
9092       {
9093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9094       };
9095     } catch (Dali::DaliException e) {
9096       {
9097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9098       };
9099     } catch (...) {
9100       {
9101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9102       };
9103     }
9104   }
9105
9106   jresult = result;
9107   return jresult;
9108 }
9109
9110
9111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9112   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9113   uint16_t arg2 ;
9114
9115   arg1 = (Dali::Uint16Pair *)jarg1;
9116   arg2 = (uint16_t)jarg2;
9117   {
9118     try {
9119       (arg1)->SetHeight(arg2);
9120     } catch (std::out_of_range& e) {
9121       {
9122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9123       };
9124     } catch (std::exception& e) {
9125       {
9126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9127       };
9128     } catch (Dali::DaliException e) {
9129       {
9130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9131       };
9132     } catch (...) {
9133       {
9134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9135       };
9136     }
9137   }
9138
9139 }
9140
9141
9142 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9143   unsigned short jresult ;
9144   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9145   uint16_t result;
9146
9147   arg1 = (Dali::Uint16Pair *)jarg1;
9148   {
9149     try {
9150       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9151     } catch (std::out_of_range& e) {
9152       {
9153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9154       };
9155     } catch (std::exception& e) {
9156       {
9157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9158       };
9159     } catch (Dali::DaliException e) {
9160       {
9161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9162       };
9163     } catch (...) {
9164       {
9165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9166       };
9167     }
9168   }
9169
9170   jresult = result;
9171   return jresult;
9172 }
9173
9174
9175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9176   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9177   uint16_t arg2 ;
9178
9179   arg1 = (Dali::Uint16Pair *)jarg1;
9180   arg2 = (uint16_t)jarg2;
9181   {
9182     try {
9183       (arg1)->SetX(arg2);
9184     } catch (std::out_of_range& e) {
9185       {
9186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9187       };
9188     } catch (std::exception& e) {
9189       {
9190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9191       };
9192     } catch (Dali::DaliException e) {
9193       {
9194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9195       };
9196     } catch (...) {
9197       {
9198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9199       };
9200     }
9201   }
9202
9203 }
9204
9205
9206 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9207   unsigned short jresult ;
9208   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9209   uint16_t result;
9210
9211   arg1 = (Dali::Uint16Pair *)jarg1;
9212   {
9213     try {
9214       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9215     } catch (std::out_of_range& e) {
9216       {
9217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9218       };
9219     } catch (std::exception& e) {
9220       {
9221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9222       };
9223     } catch (Dali::DaliException e) {
9224       {
9225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9226       };
9227     } catch (...) {
9228       {
9229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9230       };
9231     }
9232   }
9233
9234   jresult = result;
9235   return jresult;
9236 }
9237
9238
9239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9240   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9241   uint16_t arg2 ;
9242
9243   arg1 = (Dali::Uint16Pair *)jarg1;
9244   arg2 = (uint16_t)jarg2;
9245   {
9246     try {
9247       (arg1)->SetY(arg2);
9248     } catch (std::out_of_range& e) {
9249       {
9250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9251       };
9252     } catch (std::exception& e) {
9253       {
9254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9255       };
9256     } catch (Dali::DaliException e) {
9257       {
9258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9259       };
9260     } catch (...) {
9261       {
9262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9263       };
9264     }
9265   }
9266
9267 }
9268
9269
9270 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9271   unsigned short jresult ;
9272   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9273   uint16_t result;
9274
9275   arg1 = (Dali::Uint16Pair *)jarg1;
9276   {
9277     try {
9278       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9279     } catch (std::out_of_range& e) {
9280       {
9281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9282       };
9283     } catch (std::exception& e) {
9284       {
9285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9286       };
9287     } catch (Dali::DaliException e) {
9288       {
9289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9290       };
9291     } catch (...) {
9292       {
9293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9294       };
9295     }
9296   }
9297
9298   jresult = result;
9299   return jresult;
9300 }
9301
9302
9303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9304   void * jresult ;
9305   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9306   Dali::Uint16Pair *arg2 = 0 ;
9307   Dali::Uint16Pair *result = 0 ;
9308
9309   arg1 = (Dali::Uint16Pair *)jarg1;
9310   arg2 = (Dali::Uint16Pair *)jarg2;
9311   if (!arg2) {
9312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9313     return 0;
9314   }
9315   {
9316     try {
9317       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9318     } catch (std::out_of_range& e) {
9319       {
9320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9321       };
9322     } catch (std::exception& e) {
9323       {
9324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9325       };
9326     } catch (Dali::DaliException e) {
9327       {
9328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9329       };
9330     } catch (...) {
9331       {
9332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9333       };
9334     }
9335   }
9336
9337   jresult = (void *)result;
9338   return jresult;
9339 }
9340
9341
9342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9343   unsigned int jresult ;
9344   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9345   Dali::Uint16Pair *arg2 = 0 ;
9346   bool result;
9347
9348   arg1 = (Dali::Uint16Pair *)jarg1;
9349   arg2 = (Dali::Uint16Pair *)jarg2;
9350   if (!arg2) {
9351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9352     return 0;
9353   }
9354   {
9355     try {
9356       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9357     } catch (std::out_of_range& e) {
9358       {
9359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9360       };
9361     } catch (std::exception& e) {
9362       {
9363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9364       };
9365     } catch (Dali::DaliException e) {
9366       {
9367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9368       };
9369     } catch (...) {
9370       {
9371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9372       };
9373     }
9374   }
9375
9376   jresult = result;
9377   return jresult;
9378 }
9379
9380
9381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9382   unsigned int jresult ;
9383   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9384   Dali::Uint16Pair *arg2 = 0 ;
9385   bool result;
9386
9387   arg1 = (Dali::Uint16Pair *)jarg1;
9388   arg2 = (Dali::Uint16Pair *)jarg2;
9389   if (!arg2) {
9390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9391     return 0;
9392   }
9393   {
9394     try {
9395       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9396     } catch (std::out_of_range& e) {
9397       {
9398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9399       };
9400     } catch (std::exception& e) {
9401       {
9402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9403       };
9404     } catch (Dali::DaliException e) {
9405       {
9406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9407       };
9408     } catch (...) {
9409       {
9410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9411       };
9412     }
9413   }
9414
9415   jresult = result;
9416   return jresult;
9417 }
9418
9419
9420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9421   unsigned int jresult ;
9422   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9423   Dali::Uint16Pair *arg2 = 0 ;
9424   bool result;
9425
9426   arg1 = (Dali::Uint16Pair *)jarg1;
9427   arg2 = (Dali::Uint16Pair *)jarg2;
9428   if (!arg2) {
9429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9430     return 0;
9431   }
9432   {
9433     try {
9434       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9435     } catch (std::out_of_range& e) {
9436       {
9437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9438       };
9439     } catch (std::exception& e) {
9440       {
9441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9442       };
9443     } catch (Dali::DaliException e) {
9444       {
9445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9446       };
9447     } catch (...) {
9448       {
9449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9450       };
9451     }
9452   }
9453
9454   jresult = result;
9455   return jresult;
9456 }
9457
9458
9459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9460   unsigned int jresult ;
9461   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9462   Dali::Uint16Pair *arg2 = 0 ;
9463   bool result;
9464
9465   arg1 = (Dali::Uint16Pair *)jarg1;
9466   arg2 = (Dali::Uint16Pair *)jarg2;
9467   if (!arg2) {
9468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9469     return 0;
9470   }
9471   {
9472     try {
9473       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9474     } catch (std::out_of_range& e) {
9475       {
9476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9477       };
9478     } catch (std::exception& e) {
9479       {
9480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9481       };
9482     } catch (Dali::DaliException e) {
9483       {
9484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9485       };
9486     } catch (...) {
9487       {
9488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9489       };
9490     }
9491   }
9492
9493   jresult = result;
9494   return jresult;
9495 }
9496
9497
9498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9499   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9500
9501   arg1 = (Dali::Uint16Pair *)jarg1;
9502   {
9503     try {
9504       delete arg1;
9505     } catch (std::out_of_range& e) {
9506       {
9507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9508       };
9509     } catch (std::exception& e) {
9510       {
9511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9512       };
9513     } catch (Dali::DaliException e) {
9514       {
9515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9516       };
9517     } catch (...) {
9518       {
9519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9520       };
9521     }
9522   }
9523
9524 }
9525
9526
9527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9528   void * jresult ;
9529   Dali::Degree *result = 0 ;
9530
9531   {
9532     try {
9533       result = (Dali::Degree *)new Dali::Degree();
9534     } catch (std::out_of_range& e) {
9535       {
9536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9537       };
9538     } catch (std::exception& e) {
9539       {
9540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9541       };
9542     } catch (Dali::DaliException e) {
9543       {
9544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9545       };
9546     } catch (...) {
9547       {
9548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9549       };
9550     }
9551   }
9552
9553   jresult = (void *)result;
9554   return jresult;
9555 }
9556
9557
9558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9559   void * jresult ;
9560   float arg1 ;
9561   Dali::Degree *result = 0 ;
9562
9563   arg1 = (float)jarg1;
9564   {
9565     try {
9566       result = (Dali::Degree *)new Dali::Degree(arg1);
9567     } catch (std::out_of_range& e) {
9568       {
9569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9570       };
9571     } catch (std::exception& e) {
9572       {
9573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9574       };
9575     } catch (Dali::DaliException e) {
9576       {
9577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9578       };
9579     } catch (...) {
9580       {
9581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9582       };
9583     }
9584   }
9585
9586   jresult = (void *)result;
9587   return jresult;
9588 }
9589
9590
9591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9592   void * jresult ;
9593   Dali::Radian arg1 ;
9594   Dali::Radian *argp1 ;
9595   Dali::Degree *result = 0 ;
9596
9597   argp1 = (Dali::Radian *)jarg1;
9598   if (!argp1) {
9599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9600     return 0;
9601   }
9602   arg1 = *argp1;
9603   {
9604     try {
9605       result = (Dali::Degree *)new Dali::Degree(arg1);
9606     } catch (std::out_of_range& e) {
9607       {
9608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9609       };
9610     } catch (std::exception& e) {
9611       {
9612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9613       };
9614     } catch (Dali::DaliException e) {
9615       {
9616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9617       };
9618     } catch (...) {
9619       {
9620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9621       };
9622     }
9623   }
9624
9625   jresult = (void *)result;
9626   return jresult;
9627 }
9628
9629
9630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9631   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9632   float arg2 ;
9633
9634   arg1 = (Dali::Degree *)jarg1;
9635   arg2 = (float)jarg2;
9636   if (arg1) (arg1)->degree = arg2;
9637 }
9638
9639
9640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9641   float jresult ;
9642   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9643   float result;
9644
9645   arg1 = (Dali::Degree *)jarg1;
9646   result = (float) ((arg1)->degree);
9647   jresult = result;
9648   return jresult;
9649 }
9650
9651
9652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9653   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9654
9655   arg1 = (Dali::Degree *)jarg1;
9656   {
9657     try {
9658       delete arg1;
9659     } catch (std::out_of_range& e) {
9660       {
9661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9662       };
9663     } catch (std::exception& e) {
9664       {
9665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9666       };
9667     } catch (Dali::DaliException e) {
9668       {
9669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9670       };
9671     } catch (...) {
9672       {
9673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9674       };
9675     }
9676   }
9677
9678 }
9679
9680
9681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9682   void * jresult ;
9683   Dali::Radian *result = 0 ;
9684
9685   result = (Dali::Radian *)&Dali::ANGLE_360;
9686   jresult = (void *)result;
9687   return jresult;
9688 }
9689
9690
9691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9692   void * jresult ;
9693   Dali::Radian *result = 0 ;
9694
9695   result = (Dali::Radian *)&Dali::ANGLE_315;
9696   jresult = (void *)result;
9697   return jresult;
9698 }
9699
9700
9701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9702   void * jresult ;
9703   Dali::Radian *result = 0 ;
9704
9705   result = (Dali::Radian *)&Dali::ANGLE_270;
9706   jresult = (void *)result;
9707   return jresult;
9708 }
9709
9710
9711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9712   void * jresult ;
9713   Dali::Radian *result = 0 ;
9714
9715   result = (Dali::Radian *)&Dali::ANGLE_225;
9716   jresult = (void *)result;
9717   return jresult;
9718 }
9719
9720
9721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9722   void * jresult ;
9723   Dali::Radian *result = 0 ;
9724
9725   result = (Dali::Radian *)&Dali::ANGLE_180;
9726   jresult = (void *)result;
9727   return jresult;
9728 }
9729
9730
9731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9732   void * jresult ;
9733   Dali::Radian *result = 0 ;
9734
9735   result = (Dali::Radian *)&Dali::ANGLE_135;
9736   jresult = (void *)result;
9737   return jresult;
9738 }
9739
9740
9741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9742   void * jresult ;
9743   Dali::Radian *result = 0 ;
9744
9745   result = (Dali::Radian *)&Dali::ANGLE_120;
9746   jresult = (void *)result;
9747   return jresult;
9748 }
9749
9750
9751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9752   void * jresult ;
9753   Dali::Radian *result = 0 ;
9754
9755   result = (Dali::Radian *)&Dali::ANGLE_90;
9756   jresult = (void *)result;
9757   return jresult;
9758 }
9759
9760
9761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9762   void * jresult ;
9763   Dali::Radian *result = 0 ;
9764
9765   result = (Dali::Radian *)&Dali::ANGLE_60;
9766   jresult = (void *)result;
9767   return jresult;
9768 }
9769
9770
9771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9772   void * jresult ;
9773   Dali::Radian *result = 0 ;
9774
9775   result = (Dali::Radian *)&Dali::ANGLE_45;
9776   jresult = (void *)result;
9777   return jresult;
9778 }
9779
9780
9781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9782   void * jresult ;
9783   Dali::Radian *result = 0 ;
9784
9785   result = (Dali::Radian *)&Dali::ANGLE_30;
9786   jresult = (void *)result;
9787   return jresult;
9788 }
9789
9790
9791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9792   void * jresult ;
9793   Dali::Radian *result = 0 ;
9794
9795   result = (Dali::Radian *)&Dali::ANGLE_0;
9796   jresult = (void *)result;
9797   return jresult;
9798 }
9799
9800
9801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9802   unsigned int jresult ;
9803   Dali::Degree *arg1 = 0 ;
9804   Dali::Degree *arg2 = 0 ;
9805   bool result;
9806
9807   arg1 = (Dali::Degree *)jarg1;
9808   if (!arg1) {
9809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9810     return 0;
9811   }
9812   arg2 = (Dali::Degree *)jarg2;
9813   if (!arg2) {
9814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9815     return 0;
9816   }
9817   {
9818     try {
9819       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9820     } catch (std::out_of_range& e) {
9821       {
9822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9823       };
9824     } catch (std::exception& e) {
9825       {
9826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9827       };
9828     } catch (Dali::DaliException e) {
9829       {
9830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9831       };
9832     } catch (...) {
9833       {
9834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9835       };
9836     }
9837   }
9838
9839   jresult = result;
9840   return jresult;
9841 }
9842
9843
9844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9845   unsigned int jresult ;
9846   Dali::Degree *arg1 = 0 ;
9847   Dali::Degree *arg2 = 0 ;
9848   bool result;
9849
9850   arg1 = (Dali::Degree *)jarg1;
9851   if (!arg1) {
9852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9853     return 0;
9854   }
9855   arg2 = (Dali::Degree *)jarg2;
9856   if (!arg2) {
9857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9858     return 0;
9859   }
9860   {
9861     try {
9862       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9863     } catch (std::out_of_range& e) {
9864       {
9865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9866       };
9867     } catch (std::exception& e) {
9868       {
9869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9870       };
9871     } catch (Dali::DaliException e) {
9872       {
9873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9874       };
9875     } catch (...) {
9876       {
9877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9878       };
9879     }
9880   }
9881
9882   jresult = result;
9883   return jresult;
9884 }
9885
9886
9887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9888   void * jresult ;
9889   Dali::Degree arg1 ;
9890   float arg2 ;
9891   float arg3 ;
9892   Dali::Degree *argp1 ;
9893   Dali::Degree result;
9894
9895   argp1 = (Dali::Degree *)jarg1;
9896   if (!argp1) {
9897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9898     return 0;
9899   }
9900   arg1 = *argp1;
9901   arg2 = (float)jarg2;
9902   arg3 = (float)jarg3;
9903   {
9904     try {
9905       result = Dali::Clamp(arg1,arg2,arg3);
9906     } catch (std::out_of_range& e) {
9907       {
9908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9909       };
9910     } catch (std::exception& e) {
9911       {
9912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9913       };
9914     } catch (Dali::DaliException e) {
9915       {
9916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9917       };
9918     } catch (...) {
9919       {
9920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9921       };
9922     }
9923   }
9924
9925   jresult = new Dali::Degree((const Dali::Degree &)result);
9926   return jresult;
9927 }
9928
9929
9930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9931   void * jresult ;
9932   Dali::Radian *result = 0 ;
9933
9934   {
9935     try {
9936       result = (Dali::Radian *)new Dali::Radian();
9937     } catch (std::out_of_range& e) {
9938       {
9939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9940       };
9941     } catch (std::exception& e) {
9942       {
9943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9944       };
9945     } catch (Dali::DaliException e) {
9946       {
9947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9948       };
9949     } catch (...) {
9950       {
9951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9952       };
9953     }
9954   }
9955
9956   jresult = (void *)result;
9957   return jresult;
9958 }
9959
9960
9961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9962   void * jresult ;
9963   float arg1 ;
9964   Dali::Radian *result = 0 ;
9965
9966   arg1 = (float)jarg1;
9967   {
9968     try {
9969       result = (Dali::Radian *)new Dali::Radian(arg1);
9970     } catch (std::out_of_range& e) {
9971       {
9972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9973       };
9974     } catch (std::exception& e) {
9975       {
9976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9977       };
9978     } catch (Dali::DaliException e) {
9979       {
9980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9981       };
9982     } catch (...) {
9983       {
9984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9985       };
9986     }
9987   }
9988
9989   jresult = (void *)result;
9990   return jresult;
9991 }
9992
9993
9994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9995   void * jresult ;
9996   Dali::Degree arg1 ;
9997   Dali::Degree *argp1 ;
9998   Dali::Radian *result = 0 ;
9999
10000   argp1 = (Dali::Degree *)jarg1;
10001   if (!argp1) {
10002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10003     return 0;
10004   }
10005   arg1 = *argp1;
10006   {
10007     try {
10008       result = (Dali::Radian *)new Dali::Radian(arg1);
10009     } catch (std::out_of_range& e) {
10010       {
10011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10012       };
10013     } catch (std::exception& e) {
10014       {
10015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10016       };
10017     } catch (Dali::DaliException e) {
10018       {
10019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10020       };
10021     } catch (...) {
10022       {
10023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10024       };
10025     }
10026   }
10027
10028   jresult = (void *)result;
10029   return jresult;
10030 }
10031
10032
10033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10034   void * jresult ;
10035   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10036   float arg2 ;
10037   Dali::Radian *result = 0 ;
10038
10039   arg1 = (Dali::Radian *)jarg1;
10040   arg2 = (float)jarg2;
10041   {
10042     try {
10043       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10044     } catch (std::out_of_range& e) {
10045       {
10046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10047       };
10048     } catch (std::exception& e) {
10049       {
10050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10051       };
10052     } catch (Dali::DaliException e) {
10053       {
10054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10055       };
10056     } catch (...) {
10057       {
10058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10059       };
10060     }
10061   }
10062
10063   jresult = (void *)result;
10064   return jresult;
10065 }
10066
10067
10068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10069   void * jresult ;
10070   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10071   Dali::Degree arg2 ;
10072   Dali::Degree *argp2 ;
10073   Dali::Radian *result = 0 ;
10074
10075   arg1 = (Dali::Radian *)jarg1;
10076   argp2 = (Dali::Degree *)jarg2;
10077   if (!argp2) {
10078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10079     return 0;
10080   }
10081   arg2 = *argp2;
10082   {
10083     try {
10084       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10085     } catch (std::out_of_range& e) {
10086       {
10087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10088       };
10089     } catch (std::exception& e) {
10090       {
10091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10092       };
10093     } catch (Dali::DaliException e) {
10094       {
10095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10096       };
10097     } catch (...) {
10098       {
10099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10100       };
10101     }
10102   }
10103
10104   jresult = (void *)result;
10105   return jresult;
10106 }
10107
10108
10109 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10110   float jresult ;
10111   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10112   float result;
10113
10114   arg1 = (Dali::Radian *)jarg1;
10115   {
10116     try {
10117       result = (float)((Dali::Radian const *)arg1)->operator float();
10118     } catch (std::out_of_range& e) {
10119       {
10120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10121       };
10122     } catch (std::exception& e) {
10123       {
10124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10125       };
10126     } catch (Dali::DaliException e) {
10127       {
10128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10129       };
10130     } catch (...) {
10131       {
10132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10133       };
10134     }
10135   }
10136
10137   jresult = result;
10138   return jresult;
10139 }
10140
10141
10142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10143   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10144   float arg2 ;
10145
10146   arg1 = (Dali::Radian *)jarg1;
10147   arg2 = (float)jarg2;
10148   if (arg1) (arg1)->radian = arg2;
10149 }
10150
10151
10152 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10153   float jresult ;
10154   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10155   float result;
10156
10157   arg1 = (Dali::Radian *)jarg1;
10158   result = (float) ((arg1)->radian);
10159   jresult = result;
10160   return jresult;
10161 }
10162
10163
10164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10165   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10166
10167   arg1 = (Dali::Radian *)jarg1;
10168   {
10169     try {
10170       delete arg1;
10171     } catch (std::out_of_range& e) {
10172       {
10173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10174       };
10175     } catch (std::exception& e) {
10176       {
10177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10178       };
10179     } catch (Dali::DaliException e) {
10180       {
10181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10182       };
10183     } catch (...) {
10184       {
10185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10186       };
10187     }
10188   }
10189
10190 }
10191
10192
10193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10194   unsigned int jresult ;
10195   Dali::Radian arg1 ;
10196   Dali::Radian arg2 ;
10197   Dali::Radian *argp1 ;
10198   Dali::Radian *argp2 ;
10199   bool result;
10200
10201   argp1 = (Dali::Radian *)jarg1;
10202   if (!argp1) {
10203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10204     return 0;
10205   }
10206   arg1 = *argp1;
10207   argp2 = (Dali::Radian *)jarg2;
10208   if (!argp2) {
10209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10210     return 0;
10211   }
10212   arg2 = *argp2;
10213   {
10214     try {
10215       result = (bool)Dali::operator ==(arg1,arg2);
10216     } catch (std::out_of_range& e) {
10217       {
10218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10219       };
10220     } catch (std::exception& e) {
10221       {
10222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10223       };
10224     } catch (Dali::DaliException e) {
10225       {
10226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10227       };
10228     } catch (...) {
10229       {
10230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10231       };
10232     }
10233   }
10234
10235   jresult = result;
10236   return jresult;
10237 }
10238
10239
10240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10241   unsigned int jresult ;
10242   Dali::Radian arg1 ;
10243   Dali::Radian arg2 ;
10244   Dali::Radian *argp1 ;
10245   Dali::Radian *argp2 ;
10246   bool result;
10247
10248   argp1 = (Dali::Radian *)jarg1;
10249   if (!argp1) {
10250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10251     return 0;
10252   }
10253   arg1 = *argp1;
10254   argp2 = (Dali::Radian *)jarg2;
10255   if (!argp2) {
10256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10257     return 0;
10258   }
10259   arg2 = *argp2;
10260   {
10261     try {
10262       result = (bool)Dali::operator !=(arg1,arg2);
10263     } catch (std::out_of_range& e) {
10264       {
10265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10266       };
10267     } catch (std::exception& e) {
10268       {
10269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10270       };
10271     } catch (Dali::DaliException e) {
10272       {
10273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10274       };
10275     } catch (...) {
10276       {
10277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10278       };
10279     }
10280   }
10281
10282   jresult = result;
10283   return jresult;
10284 }
10285
10286
10287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10288   unsigned int jresult ;
10289   Dali::Radian arg1 ;
10290   Dali::Degree arg2 ;
10291   Dali::Radian *argp1 ;
10292   Dali::Degree *argp2 ;
10293   bool result;
10294
10295   argp1 = (Dali::Radian *)jarg1;
10296   if (!argp1) {
10297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10298     return 0;
10299   }
10300   arg1 = *argp1;
10301   argp2 = (Dali::Degree *)jarg2;
10302   if (!argp2) {
10303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10304     return 0;
10305   }
10306   arg2 = *argp2;
10307   {
10308     try {
10309       result = (bool)Dali::operator ==(arg1,arg2);
10310     } catch (std::out_of_range& e) {
10311       {
10312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10313       };
10314     } catch (std::exception& e) {
10315       {
10316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10317       };
10318     } catch (Dali::DaliException e) {
10319       {
10320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10321       };
10322     } catch (...) {
10323       {
10324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10325       };
10326     }
10327   }
10328
10329   jresult = result;
10330   return jresult;
10331 }
10332
10333
10334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10335   unsigned int jresult ;
10336   Dali::Radian arg1 ;
10337   Dali::Degree arg2 ;
10338   Dali::Radian *argp1 ;
10339   Dali::Degree *argp2 ;
10340   bool result;
10341
10342   argp1 = (Dali::Radian *)jarg1;
10343   if (!argp1) {
10344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10345     return 0;
10346   }
10347   arg1 = *argp1;
10348   argp2 = (Dali::Degree *)jarg2;
10349   if (!argp2) {
10350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10351     return 0;
10352   }
10353   arg2 = *argp2;
10354   {
10355     try {
10356       result = (bool)Dali::operator !=(arg1,arg2);
10357     } catch (std::out_of_range& e) {
10358       {
10359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10360       };
10361     } catch (std::exception& e) {
10362       {
10363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10364       };
10365     } catch (Dali::DaliException e) {
10366       {
10367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10368       };
10369     } catch (...) {
10370       {
10371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10372       };
10373     }
10374   }
10375
10376   jresult = result;
10377   return jresult;
10378 }
10379
10380
10381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10382   unsigned int jresult ;
10383   Dali::Degree arg1 ;
10384   Dali::Radian arg2 ;
10385   Dali::Degree *argp1 ;
10386   Dali::Radian *argp2 ;
10387   bool result;
10388
10389   argp1 = (Dali::Degree *)jarg1;
10390   if (!argp1) {
10391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10392     return 0;
10393   }
10394   arg1 = *argp1;
10395   argp2 = (Dali::Radian *)jarg2;
10396   if (!argp2) {
10397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10398     return 0;
10399   }
10400   arg2 = *argp2;
10401   {
10402     try {
10403       result = (bool)Dali::operator ==(arg1,arg2);
10404     } catch (std::out_of_range& e) {
10405       {
10406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10407       };
10408     } catch (std::exception& e) {
10409       {
10410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10411       };
10412     } catch (Dali::DaliException e) {
10413       {
10414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10415       };
10416     } catch (...) {
10417       {
10418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10419       };
10420     }
10421   }
10422
10423   jresult = result;
10424   return jresult;
10425 }
10426
10427
10428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10429   unsigned int jresult ;
10430   Dali::Degree arg1 ;
10431   Dali::Radian arg2 ;
10432   Dali::Degree *argp1 ;
10433   Dali::Radian *argp2 ;
10434   bool result;
10435
10436   argp1 = (Dali::Degree *)jarg1;
10437   if (!argp1) {
10438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10439     return 0;
10440   }
10441   arg1 = *argp1;
10442   argp2 = (Dali::Radian *)jarg2;
10443   if (!argp2) {
10444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10445     return 0;
10446   }
10447   arg2 = *argp2;
10448   {
10449     try {
10450       result = (bool)Dali::operator !=(arg1,arg2);
10451     } catch (std::out_of_range& e) {
10452       {
10453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10454       };
10455     } catch (std::exception& e) {
10456       {
10457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10458       };
10459     } catch (Dali::DaliException e) {
10460       {
10461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10462       };
10463     } catch (...) {
10464       {
10465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10466       };
10467     }
10468   }
10469
10470   jresult = result;
10471   return jresult;
10472 }
10473
10474
10475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10476   unsigned int jresult ;
10477   Dali::Radian arg1 ;
10478   Dali::Radian arg2 ;
10479   Dali::Radian *argp1 ;
10480   Dali::Radian *argp2 ;
10481   bool result;
10482
10483   argp1 = (Dali::Radian *)jarg1;
10484   if (!argp1) {
10485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10486     return 0;
10487   }
10488   arg1 = *argp1;
10489   argp2 = (Dali::Radian *)jarg2;
10490   if (!argp2) {
10491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10492     return 0;
10493   }
10494   arg2 = *argp2;
10495   {
10496     try {
10497       result = (bool)Dali::operator >(arg1,arg2);
10498     } catch (std::out_of_range& e) {
10499       {
10500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10501       };
10502     } catch (std::exception& e) {
10503       {
10504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10505       };
10506     } catch (Dali::DaliException e) {
10507       {
10508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10509       };
10510     } catch (...) {
10511       {
10512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10513       };
10514     }
10515   }
10516
10517   jresult = result;
10518   return jresult;
10519 }
10520
10521
10522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10523   unsigned int jresult ;
10524   Dali::Radian arg1 ;
10525   Dali::Degree arg2 ;
10526   Dali::Radian *argp1 ;
10527   Dali::Degree *argp2 ;
10528   bool result;
10529
10530   argp1 = (Dali::Radian *)jarg1;
10531   if (!argp1) {
10532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10533     return 0;
10534   }
10535   arg1 = *argp1;
10536   argp2 = (Dali::Degree *)jarg2;
10537   if (!argp2) {
10538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10539     return 0;
10540   }
10541   arg2 = *argp2;
10542   {
10543     try {
10544       result = (bool)Dali::operator >(arg1,arg2);
10545     } catch (std::out_of_range& e) {
10546       {
10547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10548       };
10549     } catch (std::exception& e) {
10550       {
10551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10552       };
10553     } catch (Dali::DaliException e) {
10554       {
10555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10556       };
10557     } catch (...) {
10558       {
10559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10560       };
10561     }
10562   }
10563
10564   jresult = result;
10565   return jresult;
10566 }
10567
10568
10569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10570   unsigned int jresult ;
10571   Dali::Degree arg1 ;
10572   Dali::Radian arg2 ;
10573   Dali::Degree *argp1 ;
10574   Dali::Radian *argp2 ;
10575   bool result;
10576
10577   argp1 = (Dali::Degree *)jarg1;
10578   if (!argp1) {
10579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10580     return 0;
10581   }
10582   arg1 = *argp1;
10583   argp2 = (Dali::Radian *)jarg2;
10584   if (!argp2) {
10585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10586     return 0;
10587   }
10588   arg2 = *argp2;
10589   {
10590     try {
10591       result = (bool)Dali::operator >(arg1,arg2);
10592     } catch (std::out_of_range& e) {
10593       {
10594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10595       };
10596     } catch (std::exception& e) {
10597       {
10598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10599       };
10600     } catch (Dali::DaliException e) {
10601       {
10602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10603       };
10604     } catch (...) {
10605       {
10606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10607       };
10608     }
10609   }
10610
10611   jresult = result;
10612   return jresult;
10613 }
10614
10615
10616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10617   unsigned int jresult ;
10618   Dali::Radian arg1 ;
10619   Dali::Radian arg2 ;
10620   Dali::Radian *argp1 ;
10621   Dali::Radian *argp2 ;
10622   bool result;
10623
10624   argp1 = (Dali::Radian *)jarg1;
10625   if (!argp1) {
10626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10627     return 0;
10628   }
10629   arg1 = *argp1;
10630   argp2 = (Dali::Radian *)jarg2;
10631   if (!argp2) {
10632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10633     return 0;
10634   }
10635   arg2 = *argp2;
10636   {
10637     try {
10638       result = (bool)Dali::operator <(arg1,arg2);
10639     } catch (std::out_of_range& e) {
10640       {
10641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10642       };
10643     } catch (std::exception& e) {
10644       {
10645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10646       };
10647     } catch (Dali::DaliException e) {
10648       {
10649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10650       };
10651     } catch (...) {
10652       {
10653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10654       };
10655     }
10656   }
10657
10658   jresult = result;
10659   return jresult;
10660 }
10661
10662
10663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10664   unsigned int jresult ;
10665   Dali::Radian arg1 ;
10666   Dali::Degree arg2 ;
10667   Dali::Radian *argp1 ;
10668   Dali::Degree *argp2 ;
10669   bool result;
10670
10671   argp1 = (Dali::Radian *)jarg1;
10672   if (!argp1) {
10673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10674     return 0;
10675   }
10676   arg1 = *argp1;
10677   argp2 = (Dali::Degree *)jarg2;
10678   if (!argp2) {
10679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10680     return 0;
10681   }
10682   arg2 = *argp2;
10683   {
10684     try {
10685       result = (bool)Dali::operator <(arg1,arg2);
10686     } catch (std::out_of_range& e) {
10687       {
10688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10689       };
10690     } catch (std::exception& e) {
10691       {
10692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10693       };
10694     } catch (Dali::DaliException e) {
10695       {
10696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10697       };
10698     } catch (...) {
10699       {
10700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10701       };
10702     }
10703   }
10704
10705   jresult = result;
10706   return jresult;
10707 }
10708
10709
10710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10711   unsigned int jresult ;
10712   Dali::Degree arg1 ;
10713   Dali::Radian arg2 ;
10714   Dali::Degree *argp1 ;
10715   Dali::Radian *argp2 ;
10716   bool result;
10717
10718   argp1 = (Dali::Degree *)jarg1;
10719   if (!argp1) {
10720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10721     return 0;
10722   }
10723   arg1 = *argp1;
10724   argp2 = (Dali::Radian *)jarg2;
10725   if (!argp2) {
10726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10727     return 0;
10728   }
10729   arg2 = *argp2;
10730   {
10731     try {
10732       result = (bool)Dali::operator <(arg1,arg2);
10733     } catch (std::out_of_range& e) {
10734       {
10735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10736       };
10737     } catch (std::exception& e) {
10738       {
10739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10740       };
10741     } catch (Dali::DaliException e) {
10742       {
10743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10744       };
10745     } catch (...) {
10746       {
10747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10748       };
10749     }
10750   }
10751
10752   jresult = result;
10753   return jresult;
10754 }
10755
10756
10757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10758   void * jresult ;
10759   Dali::Radian arg1 ;
10760   float arg2 ;
10761   Dali::Radian *argp1 ;
10762   Dali::Radian result;
10763
10764   argp1 = (Dali::Radian *)jarg1;
10765   if (!argp1) {
10766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10767     return 0;
10768   }
10769   arg1 = *argp1;
10770   arg2 = (float)jarg2;
10771   {
10772     try {
10773       result = Dali::operator *(arg1,arg2);
10774     } catch (std::out_of_range& e) {
10775       {
10776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10777       };
10778     } catch (std::exception& e) {
10779       {
10780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10781       };
10782     } catch (Dali::DaliException e) {
10783       {
10784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10785       };
10786     } catch (...) {
10787       {
10788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10789       };
10790     }
10791   }
10792
10793   jresult = new Dali::Radian((const Dali::Radian &)result);
10794   return jresult;
10795 }
10796
10797
10798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10799   void * jresult ;
10800   Dali::Radian arg1 ;
10801   Dali::Radian *argp1 ;
10802   Dali::Radian result;
10803
10804   argp1 = (Dali::Radian *)jarg1;
10805   if (!argp1) {
10806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10807     return 0;
10808   }
10809   arg1 = *argp1;
10810   {
10811     try {
10812       result = Dali::operator -(arg1);
10813     } catch (std::out_of_range& e) {
10814       {
10815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10816       };
10817     } catch (std::exception& e) {
10818       {
10819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10820       };
10821     } catch (Dali::DaliException e) {
10822       {
10823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10824       };
10825     } catch (...) {
10826       {
10827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10828       };
10829     }
10830   }
10831
10832   jresult = new Dali::Radian((const Dali::Radian &)result);
10833   return jresult;
10834 }
10835
10836
10837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10838   void * jresult ;
10839   Dali::Radian arg1 ;
10840   float arg2 ;
10841   float arg3 ;
10842   Dali::Radian *argp1 ;
10843   Dali::Radian result;
10844
10845   argp1 = (Dali::Radian *)jarg1;
10846   if (!argp1) {
10847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10848     return 0;
10849   }
10850   arg1 = *argp1;
10851   arg2 = (float)jarg2;
10852   arg3 = (float)jarg3;
10853   {
10854     try {
10855       result = Dali::Clamp(arg1,arg2,arg3);
10856     } catch (std::out_of_range& e) {
10857       {
10858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10859       };
10860     } catch (std::exception& e) {
10861       {
10862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10863       };
10864     } catch (Dali::DaliException e) {
10865       {
10866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10867       };
10868     } catch (...) {
10869       {
10870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10871       };
10872     }
10873   }
10874
10875   jresult = new Dali::Radian((const Dali::Radian &)result);
10876   return jresult;
10877 }
10878
10879
10880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10881   void * jresult ;
10882   Dali::Quaternion *result = 0 ;
10883
10884   {
10885     try {
10886       result = (Dali::Quaternion *)new Dali::Quaternion();
10887     } catch (std::out_of_range& e) {
10888       {
10889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10890       };
10891     } catch (std::exception& e) {
10892       {
10893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10894       };
10895     } catch (Dali::DaliException e) {
10896       {
10897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10898       };
10899     } catch (...) {
10900       {
10901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10902       };
10903     }
10904   }
10905
10906   jresult = (void *)result;
10907   return jresult;
10908 }
10909
10910
10911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10912   void * jresult ;
10913   Dali::Radian arg1 ;
10914   Dali::Vector3 *arg2 = 0 ;
10915   Dali::Radian *argp1 ;
10916   Dali::Quaternion *result = 0 ;
10917
10918   argp1 = (Dali::Radian *)jarg1;
10919   if (!argp1) {
10920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10921     return 0;
10922   }
10923   arg1 = *argp1;
10924   arg2 = (Dali::Vector3 *)jarg2;
10925   if (!arg2) {
10926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10927     return 0;
10928   }
10929   {
10930     try {
10931       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10932     } catch (std::out_of_range& e) {
10933       {
10934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10935       };
10936     } catch (std::exception& e) {
10937       {
10938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10939       };
10940     } catch (Dali::DaliException e) {
10941       {
10942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10943       };
10944     } catch (...) {
10945       {
10946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10947       };
10948     }
10949   }
10950
10951   jresult = (void *)result;
10952   return jresult;
10953 }
10954
10955
10956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10957   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10958
10959   arg1 = (Dali::Quaternion *)jarg1;
10960   {
10961     try {
10962       delete arg1;
10963     } catch (std::out_of_range& e) {
10964       {
10965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10966       };
10967     } catch (std::exception& e) {
10968       {
10969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10970       };
10971     } catch (Dali::DaliException e) {
10972       {
10973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10974       };
10975     } catch (...) {
10976       {
10977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10978       };
10979     }
10980   }
10981
10982 }
10983
10984
10985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10986   void * jresult ;
10987   Dali::Quaternion *result = 0 ;
10988
10989   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10990   jresult = (void *)result;
10991   return jresult;
10992 }
10993
10994
10995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10996   unsigned int jresult ;
10997   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10998   bool result;
10999
11000   arg1 = (Dali::Quaternion *)jarg1;
11001   {
11002     try {
11003       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11004     } catch (std::out_of_range& e) {
11005       {
11006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11007       };
11008     } catch (std::exception& e) {
11009       {
11010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11011       };
11012     } catch (Dali::DaliException e) {
11013       {
11014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11015       };
11016     } catch (...) {
11017       {
11018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11019       };
11020     }
11021   }
11022
11023   jresult = result;
11024   return jresult;
11025 }
11026
11027
11028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11029   unsigned int jresult ;
11030   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11031   Dali::Vector3 *arg2 = 0 ;
11032   Dali::Radian *arg3 = 0 ;
11033   bool result;
11034
11035   arg1 = (Dali::Quaternion *)jarg1;
11036   arg2 = (Dali::Vector3 *)jarg2;
11037   if (!arg2) {
11038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11039     return 0;
11040   }
11041   arg3 = (Dali::Radian *)jarg3;
11042   if (!arg3) {
11043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11044     return 0;
11045   }
11046   {
11047     try {
11048       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11049     } catch (std::out_of_range& e) {
11050       {
11051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11052       };
11053     } catch (std::exception& e) {
11054       {
11055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11056       };
11057     } catch (Dali::DaliException e) {
11058       {
11059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11060       };
11061     } catch (...) {
11062       {
11063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11064       };
11065     }
11066   }
11067
11068   jresult = result;
11069   return jresult;
11070 }
11071
11072
11073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11074   void * jresult ;
11075   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11076   Dali::Quaternion *arg2 = 0 ;
11077   Dali::Quaternion result;
11078
11079   arg1 = (Dali::Quaternion *)jarg1;
11080   arg2 = (Dali::Quaternion *)jarg2;
11081   if (!arg2) {
11082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11083     return 0;
11084   }
11085   {
11086     try {
11087       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11088     } catch (std::out_of_range& e) {
11089       {
11090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11091       };
11092     } catch (std::exception& e) {
11093       {
11094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11095       };
11096     } catch (Dali::DaliException e) {
11097       {
11098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11099       };
11100     } catch (...) {
11101       {
11102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11103       };
11104     }
11105   }
11106
11107   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11108   return jresult;
11109 }
11110
11111
11112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11113   void * jresult ;
11114   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11115   Dali::Quaternion *arg2 = 0 ;
11116   Dali::Quaternion result;
11117
11118   arg1 = (Dali::Quaternion *)jarg1;
11119   arg2 = (Dali::Quaternion *)jarg2;
11120   if (!arg2) {
11121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11122     return 0;
11123   }
11124   {
11125     try {
11126       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11127     } catch (std::out_of_range& e) {
11128       {
11129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11130       };
11131     } catch (std::exception& e) {
11132       {
11133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11134       };
11135     } catch (Dali::DaliException e) {
11136       {
11137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11138       };
11139     } catch (...) {
11140       {
11141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11142       };
11143     }
11144   }
11145
11146   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11147   return jresult;
11148 }
11149
11150
11151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11152   void * jresult ;
11153   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11154   Dali::Quaternion *arg2 = 0 ;
11155   Dali::Quaternion result;
11156
11157   arg1 = (Dali::Quaternion *)jarg1;
11158   arg2 = (Dali::Quaternion *)jarg2;
11159   if (!arg2) {
11160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11161     return 0;
11162   }
11163   {
11164     try {
11165       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11166     } catch (std::out_of_range& e) {
11167       {
11168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11169       };
11170     } catch (std::exception& e) {
11171       {
11172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11173       };
11174     } catch (Dali::DaliException e) {
11175       {
11176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11177       };
11178     } catch (...) {
11179       {
11180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11181       };
11182     }
11183   }
11184
11185   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11186   return jresult;
11187 }
11188
11189
11190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11191   void * jresult ;
11192   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11193   Dali::Vector3 *arg2 = 0 ;
11194   Dali::Vector3 result;
11195
11196   arg1 = (Dali::Quaternion *)jarg1;
11197   arg2 = (Dali::Vector3 *)jarg2;
11198   if (!arg2) {
11199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11200     return 0;
11201   }
11202   {
11203     try {
11204       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11205     } catch (std::out_of_range& e) {
11206       {
11207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11208       };
11209     } catch (std::exception& e) {
11210       {
11211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11212       };
11213     } catch (Dali::DaliException e) {
11214       {
11215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11216       };
11217     } catch (...) {
11218       {
11219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11220       };
11221     }
11222   }
11223
11224   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11225   return jresult;
11226 }
11227
11228
11229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11230   void * jresult ;
11231   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11232   Dali::Quaternion *arg2 = 0 ;
11233   Dali::Quaternion result;
11234
11235   arg1 = (Dali::Quaternion *)jarg1;
11236   arg2 = (Dali::Quaternion *)jarg2;
11237   if (!arg2) {
11238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11239     return 0;
11240   }
11241   {
11242     try {
11243       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11244     } catch (std::out_of_range& e) {
11245       {
11246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11247       };
11248     } catch (std::exception& e) {
11249       {
11250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11251       };
11252     } catch (Dali::DaliException e) {
11253       {
11254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11255       };
11256     } catch (...) {
11257       {
11258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11259       };
11260     }
11261   }
11262
11263   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11264   return jresult;
11265 }
11266
11267
11268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11269   void * jresult ;
11270   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11271   float arg2 ;
11272   Dali::Quaternion result;
11273
11274   arg1 = (Dali::Quaternion *)jarg1;
11275   arg2 = (float)jarg2;
11276   {
11277     try {
11278       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11279     } catch (std::out_of_range& e) {
11280       {
11281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11282       };
11283     } catch (std::exception& e) {
11284       {
11285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11286       };
11287     } catch (Dali::DaliException e) {
11288       {
11289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11290       };
11291     } catch (...) {
11292       {
11293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11294       };
11295     }
11296   }
11297
11298   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11299   return jresult;
11300 }
11301
11302
11303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11304   void * jresult ;
11305   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11306   float arg2 ;
11307   Dali::Quaternion result;
11308
11309   arg1 = (Dali::Quaternion *)jarg1;
11310   arg2 = (float)jarg2;
11311   {
11312     try {
11313       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11314     } catch (std::out_of_range& e) {
11315       {
11316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11317       };
11318     } catch (std::exception& e) {
11319       {
11320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11321       };
11322     } catch (Dali::DaliException e) {
11323       {
11324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11325       };
11326     } catch (...) {
11327       {
11328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11329       };
11330     }
11331   }
11332
11333   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11334   return jresult;
11335 }
11336
11337
11338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11339   void * jresult ;
11340   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11341   Dali::Quaternion result;
11342
11343   arg1 = (Dali::Quaternion *)jarg1;
11344   {
11345     try {
11346       result = ((Dali::Quaternion const *)arg1)->operator -();
11347     } catch (std::out_of_range& e) {
11348       {
11349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11350       };
11351     } catch (std::exception& e) {
11352       {
11353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11354       };
11355     } catch (Dali::DaliException e) {
11356       {
11357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11358       };
11359     } catch (...) {
11360       {
11361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11362       };
11363     }
11364   }
11365
11366   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11367   return jresult;
11368 }
11369
11370
11371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11372   void * jresult ;
11373   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11374   Dali::Quaternion *arg2 = 0 ;
11375   Dali::Quaternion *result = 0 ;
11376
11377   arg1 = (Dali::Quaternion *)jarg1;
11378   arg2 = (Dali::Quaternion *)jarg2;
11379   if (!arg2) {
11380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11381     return 0;
11382   }
11383   {
11384     try {
11385       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11386     } catch (std::out_of_range& e) {
11387       {
11388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11389       };
11390     } catch (std::exception& e) {
11391       {
11392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11393       };
11394     } catch (Dali::DaliException e) {
11395       {
11396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11397       };
11398     } catch (...) {
11399       {
11400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11401       };
11402     }
11403   }
11404
11405   jresult = (void *)result;
11406   return jresult;
11407 }
11408
11409
11410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11411   void * jresult ;
11412   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11413   Dali::Quaternion *arg2 = 0 ;
11414   Dali::Quaternion *result = 0 ;
11415
11416   arg1 = (Dali::Quaternion *)jarg1;
11417   arg2 = (Dali::Quaternion *)jarg2;
11418   if (!arg2) {
11419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11420     return 0;
11421   }
11422   {
11423     try {
11424       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11425     } catch (std::out_of_range& e) {
11426       {
11427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11428       };
11429     } catch (std::exception& e) {
11430       {
11431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11432       };
11433     } catch (Dali::DaliException e) {
11434       {
11435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11436       };
11437     } catch (...) {
11438       {
11439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11440       };
11441     }
11442   }
11443
11444   jresult = (void *)result;
11445   return jresult;
11446 }
11447
11448
11449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11450   void * jresult ;
11451   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11452   Dali::Quaternion *arg2 = 0 ;
11453   Dali::Quaternion *result = 0 ;
11454
11455   arg1 = (Dali::Quaternion *)jarg1;
11456   arg2 = (Dali::Quaternion *)jarg2;
11457   if (!arg2) {
11458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11459     return 0;
11460   }
11461   {
11462     try {
11463       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11464     } catch (std::out_of_range& e) {
11465       {
11466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11467       };
11468     } catch (std::exception& e) {
11469       {
11470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11471       };
11472     } catch (Dali::DaliException e) {
11473       {
11474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11475       };
11476     } catch (...) {
11477       {
11478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11479       };
11480     }
11481   }
11482
11483   jresult = (void *)result;
11484   return jresult;
11485 }
11486
11487
11488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11489   void * jresult ;
11490   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11491   float arg2 ;
11492   Dali::Quaternion *result = 0 ;
11493
11494   arg1 = (Dali::Quaternion *)jarg1;
11495   arg2 = (float)jarg2;
11496   {
11497     try {
11498       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11499     } catch (std::out_of_range& e) {
11500       {
11501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11502       };
11503     } catch (std::exception& e) {
11504       {
11505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11506       };
11507     } catch (Dali::DaliException e) {
11508       {
11509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11510       };
11511     } catch (...) {
11512       {
11513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11514       };
11515     }
11516   }
11517
11518   jresult = (void *)result;
11519   return jresult;
11520 }
11521
11522
11523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11524   void * jresult ;
11525   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11526   float arg2 ;
11527   Dali::Quaternion *result = 0 ;
11528
11529   arg1 = (Dali::Quaternion *)jarg1;
11530   arg2 = (float)jarg2;
11531   {
11532     try {
11533       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11534     } catch (std::out_of_range& e) {
11535       {
11536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11537       };
11538     } catch (std::exception& e) {
11539       {
11540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11541       };
11542     } catch (Dali::DaliException e) {
11543       {
11544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11545       };
11546     } catch (...) {
11547       {
11548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11549       };
11550     }
11551   }
11552
11553   jresult = (void *)result;
11554   return jresult;
11555 }
11556
11557
11558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11559   unsigned int jresult ;
11560   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11561   Dali::Quaternion *arg2 = 0 ;
11562   bool result;
11563
11564   arg1 = (Dali::Quaternion *)jarg1;
11565   arg2 = (Dali::Quaternion *)jarg2;
11566   if (!arg2) {
11567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11568     return 0;
11569   }
11570   {
11571     try {
11572       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11573     } catch (std::out_of_range& e) {
11574       {
11575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11576       };
11577     } catch (std::exception& e) {
11578       {
11579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11580       };
11581     } catch (Dali::DaliException e) {
11582       {
11583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11584       };
11585     } catch (...) {
11586       {
11587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11588       };
11589     }
11590   }
11591
11592   jresult = result;
11593   return jresult;
11594 }
11595
11596
11597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11598   unsigned int jresult ;
11599   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11600   Dali::Quaternion *arg2 = 0 ;
11601   bool result;
11602
11603   arg1 = (Dali::Quaternion *)jarg1;
11604   arg2 = (Dali::Quaternion *)jarg2;
11605   if (!arg2) {
11606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11607     return 0;
11608   }
11609   {
11610     try {
11611       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11612     } catch (std::out_of_range& e) {
11613       {
11614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11615       };
11616     } catch (std::exception& e) {
11617       {
11618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11619       };
11620     } catch (Dali::DaliException e) {
11621       {
11622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11623       };
11624     } catch (...) {
11625       {
11626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11627       };
11628     }
11629   }
11630
11631   jresult = result;
11632   return jresult;
11633 }
11634
11635
11636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11637   float jresult ;
11638   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11639   float result;
11640
11641   arg1 = (Dali::Quaternion *)jarg1;
11642   {
11643     try {
11644       result = (float)((Dali::Quaternion const *)arg1)->Length();
11645     } catch (std::out_of_range& e) {
11646       {
11647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11648       };
11649     } catch (std::exception& e) {
11650       {
11651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11652       };
11653     } catch (Dali::DaliException e) {
11654       {
11655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11656       };
11657     } catch (...) {
11658       {
11659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11660       };
11661     }
11662   }
11663
11664   jresult = result;
11665   return jresult;
11666 }
11667
11668
11669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11670   float jresult ;
11671   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11672   float result;
11673
11674   arg1 = (Dali::Quaternion *)jarg1;
11675   {
11676     try {
11677       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11678     } catch (std::out_of_range& e) {
11679       {
11680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11681       };
11682     } catch (std::exception& e) {
11683       {
11684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11685       };
11686     } catch (Dali::DaliException e) {
11687       {
11688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11689       };
11690     } catch (...) {
11691       {
11692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11693       };
11694     }
11695   }
11696
11697   jresult = result;
11698   return jresult;
11699 }
11700
11701
11702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11703   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11704
11705   arg1 = (Dali::Quaternion *)jarg1;
11706   {
11707     try {
11708       (arg1)->Normalize();
11709     } catch (std::out_of_range& e) {
11710       {
11711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11712       };
11713     } catch (std::exception& e) {
11714       {
11715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11716       };
11717     } catch (Dali::DaliException e) {
11718       {
11719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11720       };
11721     } catch (...) {
11722       {
11723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11724       };
11725     }
11726   }
11727
11728 }
11729
11730
11731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11732   void * jresult ;
11733   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11734   Dali::Quaternion result;
11735
11736   arg1 = (Dali::Quaternion *)jarg1;
11737   {
11738     try {
11739       result = ((Dali::Quaternion const *)arg1)->Normalized();
11740     } catch (std::out_of_range& e) {
11741       {
11742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11743       };
11744     } catch (std::exception& e) {
11745       {
11746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11747       };
11748     } catch (Dali::DaliException e) {
11749       {
11750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11751       };
11752     } catch (...) {
11753       {
11754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11755       };
11756     }
11757   }
11758
11759   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11760   return jresult;
11761 }
11762
11763
11764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11765   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11766
11767   arg1 = (Dali::Quaternion *)jarg1;
11768   {
11769     try {
11770       (arg1)->Conjugate();
11771     } catch (std::out_of_range& e) {
11772       {
11773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11774       };
11775     } catch (std::exception& e) {
11776       {
11777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11778       };
11779     } catch (Dali::DaliException e) {
11780       {
11781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11782       };
11783     } catch (...) {
11784       {
11785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11786       };
11787     }
11788   }
11789
11790 }
11791
11792
11793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11794   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11795
11796   arg1 = (Dali::Quaternion *)jarg1;
11797   {
11798     try {
11799       (arg1)->Invert();
11800     } catch (std::out_of_range& e) {
11801       {
11802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11803       };
11804     } catch (std::exception& e) {
11805       {
11806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11807       };
11808     } catch (Dali::DaliException e) {
11809       {
11810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11811       };
11812     } catch (...) {
11813       {
11814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11815       };
11816     }
11817   }
11818
11819 }
11820
11821
11822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11823   void * jresult ;
11824   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11825   Dali::Quaternion result;
11826
11827   arg1 = (Dali::Quaternion *)jarg1;
11828   {
11829     try {
11830       result = ((Dali::Quaternion const *)arg1)->Log();
11831     } catch (std::out_of_range& e) {
11832       {
11833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11834       };
11835     } catch (std::exception& e) {
11836       {
11837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11838       };
11839     } catch (Dali::DaliException e) {
11840       {
11841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11842       };
11843     } catch (...) {
11844       {
11845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11846       };
11847     }
11848   }
11849
11850   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11851   return jresult;
11852 }
11853
11854
11855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11856   void * jresult ;
11857   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11858   Dali::Quaternion result;
11859
11860   arg1 = (Dali::Quaternion *)jarg1;
11861   {
11862     try {
11863       result = ((Dali::Quaternion const *)arg1)->Exp();
11864     } catch (std::out_of_range& e) {
11865       {
11866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11867       };
11868     } catch (std::exception& e) {
11869       {
11870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11871       };
11872     } catch (Dali::DaliException e) {
11873       {
11874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11875       };
11876     } catch (...) {
11877       {
11878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11879       };
11880     }
11881   }
11882
11883   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11884   return jresult;
11885 }
11886
11887
11888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11889   float jresult ;
11890   Dali::Quaternion *arg1 = 0 ;
11891   Dali::Quaternion *arg2 = 0 ;
11892   float result;
11893
11894   arg1 = (Dali::Quaternion *)jarg1;
11895   if (!arg1) {
11896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11897     return 0;
11898   }
11899   arg2 = (Dali::Quaternion *)jarg2;
11900   if (!arg2) {
11901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11902     return 0;
11903   }
11904   {
11905     try {
11906       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11907     } catch (std::out_of_range& e) {
11908       {
11909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11910       };
11911     } catch (std::exception& e) {
11912       {
11913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11914       };
11915     } catch (Dali::DaliException e) {
11916       {
11917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11918       };
11919     } catch (...) {
11920       {
11921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11922       };
11923     }
11924   }
11925
11926   jresult = result;
11927   return jresult;
11928 }
11929
11930
11931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11932   void * jresult ;
11933   Dali::Quaternion *arg1 = 0 ;
11934   Dali::Quaternion *arg2 = 0 ;
11935   float arg3 ;
11936   Dali::Quaternion result;
11937
11938   arg1 = (Dali::Quaternion *)jarg1;
11939   if (!arg1) {
11940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11941     return 0;
11942   }
11943   arg2 = (Dali::Quaternion *)jarg2;
11944   if (!arg2) {
11945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11946     return 0;
11947   }
11948   arg3 = (float)jarg3;
11949   {
11950     try {
11951       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11952     } catch (std::out_of_range& e) {
11953       {
11954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11955       };
11956     } catch (std::exception& e) {
11957       {
11958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11959       };
11960     } catch (Dali::DaliException e) {
11961       {
11962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11963       };
11964     } catch (...) {
11965       {
11966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11967       };
11968     }
11969   }
11970
11971   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11972   return jresult;
11973 }
11974
11975
11976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11977   void * jresult ;
11978   Dali::Quaternion *arg1 = 0 ;
11979   Dali::Quaternion *arg2 = 0 ;
11980   float arg3 ;
11981   Dali::Quaternion result;
11982
11983   arg1 = (Dali::Quaternion *)jarg1;
11984   if (!arg1) {
11985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11986     return 0;
11987   }
11988   arg2 = (Dali::Quaternion *)jarg2;
11989   if (!arg2) {
11990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11991     return 0;
11992   }
11993   arg3 = (float)jarg3;
11994   {
11995     try {
11996       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11997     } catch (std::out_of_range& e) {
11998       {
11999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12000       };
12001     } catch (std::exception& e) {
12002       {
12003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12004       };
12005     } catch (Dali::DaliException e) {
12006       {
12007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12008       };
12009     } catch (...) {
12010       {
12011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12012       };
12013     }
12014   }
12015
12016   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12017   return jresult;
12018 }
12019
12020
12021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12022   void * jresult ;
12023   Dali::Quaternion *arg1 = 0 ;
12024   Dali::Quaternion *arg2 = 0 ;
12025   float arg3 ;
12026   Dali::Quaternion result;
12027
12028   arg1 = (Dali::Quaternion *)jarg1;
12029   if (!arg1) {
12030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12031     return 0;
12032   }
12033   arg2 = (Dali::Quaternion *)jarg2;
12034   if (!arg2) {
12035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12036     return 0;
12037   }
12038   arg3 = (float)jarg3;
12039   {
12040     try {
12041       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12042     } catch (std::out_of_range& e) {
12043       {
12044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12045       };
12046     } catch (std::exception& e) {
12047       {
12048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12049       };
12050     } catch (Dali::DaliException e) {
12051       {
12052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12053       };
12054     } catch (...) {
12055       {
12056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12057       };
12058     }
12059   }
12060
12061   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12062   return jresult;
12063 }
12064
12065
12066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12067   void * jresult ;
12068   Dali::Quaternion *arg1 = 0 ;
12069   Dali::Quaternion *arg2 = 0 ;
12070   Dali::Quaternion *arg3 = 0 ;
12071   Dali::Quaternion *arg4 = 0 ;
12072   float arg5 ;
12073   Dali::Quaternion result;
12074
12075   arg1 = (Dali::Quaternion *)jarg1;
12076   if (!arg1) {
12077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12078     return 0;
12079   }
12080   arg2 = (Dali::Quaternion *)jarg2;
12081   if (!arg2) {
12082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12083     return 0;
12084   }
12085   arg3 = (Dali::Quaternion *)jarg3;
12086   if (!arg3) {
12087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12088     return 0;
12089   }
12090   arg4 = (Dali::Quaternion *)jarg4;
12091   if (!arg4) {
12092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12093     return 0;
12094   }
12095   arg5 = (float)jarg5;
12096   {
12097     try {
12098       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12099     } catch (std::out_of_range& e) {
12100       {
12101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12102       };
12103     } catch (std::exception& e) {
12104       {
12105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12106       };
12107     } catch (Dali::DaliException e) {
12108       {
12109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12110       };
12111     } catch (...) {
12112       {
12113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12114       };
12115     }
12116   }
12117
12118   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12119   return jresult;
12120 }
12121
12122
12123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12124   float jresult ;
12125   Dali::Quaternion *arg1 = 0 ;
12126   Dali::Quaternion *arg2 = 0 ;
12127   float result;
12128
12129   arg1 = (Dali::Quaternion *)jarg1;
12130   if (!arg1) {
12131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12132     return 0;
12133   }
12134   arg2 = (Dali::Quaternion *)jarg2;
12135   if (!arg2) {
12136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12137     return 0;
12138   }
12139   {
12140     try {
12141       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12142     } catch (std::out_of_range& e) {
12143       {
12144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12145       };
12146     } catch (std::exception& e) {
12147       {
12148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12149       };
12150     } catch (Dali::DaliException e) {
12151       {
12152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12153       };
12154     } catch (...) {
12155       {
12156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12157       };
12158     }
12159   }
12160
12161   jresult = result;
12162   return jresult;
12163 }
12164
12165
12166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12167   void * jresult ;
12168   Dali::Matrix *result = 0 ;
12169
12170   {
12171     try {
12172       result = (Dali::Matrix *)new Dali::Matrix();
12173     } catch (std::out_of_range& e) {
12174       {
12175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12176       };
12177     } catch (std::exception& e) {
12178       {
12179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12180       };
12181     } catch (Dali::DaliException e) {
12182       {
12183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12184       };
12185     } catch (...) {
12186       {
12187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12188       };
12189     }
12190   }
12191
12192   jresult = (void *)result;
12193   return jresult;
12194 }
12195
12196
12197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12198   void * jresult ;
12199   bool arg1 ;
12200   Dali::Matrix *result = 0 ;
12201
12202   arg1 = jarg1 ? true : false;
12203   {
12204     try {
12205       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12206     } catch (std::out_of_range& e) {
12207       {
12208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12209       };
12210     } catch (std::exception& e) {
12211       {
12212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12213       };
12214     } catch (Dali::DaliException e) {
12215       {
12216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12217       };
12218     } catch (...) {
12219       {
12220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12221       };
12222     }
12223   }
12224
12225   jresult = (void *)result;
12226   return jresult;
12227 }
12228
12229
12230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12231   void * jresult ;
12232   float *arg1 = (float *) 0 ;
12233   Dali::Matrix *result = 0 ;
12234
12235   arg1 = jarg1;
12236   {
12237     try {
12238       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12239     } catch (std::out_of_range& e) {
12240       {
12241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12242       };
12243     } catch (std::exception& e) {
12244       {
12245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12246       };
12247     } catch (Dali::DaliException e) {
12248       {
12249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12250       };
12251     } catch (...) {
12252       {
12253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12254       };
12255     }
12256   }
12257
12258   jresult = (void *)result;
12259
12260
12261   return jresult;
12262 }
12263
12264
12265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12266   void * jresult ;
12267   Dali::Quaternion *arg1 = 0 ;
12268   Dali::Matrix *result = 0 ;
12269
12270   arg1 = (Dali::Quaternion *)jarg1;
12271   if (!arg1) {
12272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12273     return 0;
12274   }
12275   {
12276     try {
12277       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12278     } catch (std::out_of_range& e) {
12279       {
12280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12281       };
12282     } catch (std::exception& e) {
12283       {
12284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12285       };
12286     } catch (Dali::DaliException e) {
12287       {
12288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12289       };
12290     } catch (...) {
12291       {
12292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12293       };
12294     }
12295   }
12296
12297   jresult = (void *)result;
12298   return jresult;
12299 }
12300
12301
12302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12303   void * jresult ;
12304   Dali::Matrix *arg1 = 0 ;
12305   Dali::Matrix *result = 0 ;
12306
12307   arg1 = (Dali::Matrix *)jarg1;
12308   if (!arg1) {
12309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12310     return 0;
12311   }
12312   {
12313     try {
12314       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12315     } catch (std::out_of_range& e) {
12316       {
12317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12318       };
12319     } catch (std::exception& e) {
12320       {
12321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12322       };
12323     } catch (Dali::DaliException e) {
12324       {
12325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12326       };
12327     } catch (...) {
12328       {
12329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12330       };
12331     }
12332   }
12333
12334   jresult = (void *)result;
12335   return jresult;
12336 }
12337
12338
12339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12340   void * jresult ;
12341   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12342   Dali::Matrix *arg2 = 0 ;
12343   Dali::Matrix *result = 0 ;
12344
12345   arg1 = (Dali::Matrix *)jarg1;
12346   arg2 = (Dali::Matrix *)jarg2;
12347   if (!arg2) {
12348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12349     return 0;
12350   }
12351   {
12352     try {
12353       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12354     } catch (std::out_of_range& e) {
12355       {
12356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12357       };
12358     } catch (std::exception& e) {
12359       {
12360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12361       };
12362     } catch (Dali::DaliException e) {
12363       {
12364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12365       };
12366     } catch (...) {
12367       {
12368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12369       };
12370     }
12371   }
12372
12373   jresult = (void *)result;
12374   return jresult;
12375 }
12376
12377
12378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12379   void * jresult ;
12380   Dali::Matrix *result = 0 ;
12381
12382   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12383   jresult = (void *)result;
12384   return jresult;
12385 }
12386
12387
12388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12389   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12390
12391   arg1 = (Dali::Matrix *)jarg1;
12392   {
12393     try {
12394       (arg1)->SetIdentity();
12395     } catch (std::out_of_range& e) {
12396       {
12397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12398       };
12399     } catch (std::exception& e) {
12400       {
12401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12402       };
12403     } catch (Dali::DaliException e) {
12404       {
12405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12406       };
12407     } catch (...) {
12408       {
12409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12410       };
12411     }
12412   }
12413
12414 }
12415
12416
12417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12418   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12419   Dali::Vector3 *arg2 = 0 ;
12420
12421   arg1 = (Dali::Matrix *)jarg1;
12422   arg2 = (Dali::Vector3 *)jarg2;
12423   if (!arg2) {
12424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12425     return ;
12426   }
12427   {
12428     try {
12429       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12430     } catch (std::out_of_range& e) {
12431       {
12432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12433       };
12434     } catch (std::exception& e) {
12435       {
12436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12437       };
12438     } catch (Dali::DaliException e) {
12439       {
12440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12441       };
12442     } catch (...) {
12443       {
12444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12445       };
12446     }
12447   }
12448
12449 }
12450
12451
12452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12453   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12454   Dali::Matrix *arg2 = 0 ;
12455
12456   arg1 = (Dali::Matrix *)jarg1;
12457   arg2 = (Dali::Matrix *)jarg2;
12458   if (!arg2) {
12459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12460     return ;
12461   }
12462   {
12463     try {
12464       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12465     } catch (std::out_of_range& e) {
12466       {
12467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12468       };
12469     } catch (std::exception& e) {
12470       {
12471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12472       };
12473     } catch (Dali::DaliException e) {
12474       {
12475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12476       };
12477     } catch (...) {
12478       {
12479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12480       };
12481     }
12482   }
12483
12484 }
12485
12486
12487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12488   unsigned int jresult ;
12489   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12490   bool result;
12491
12492   arg1 = (Dali::Matrix *)jarg1;
12493   {
12494     try {
12495       result = (bool)(arg1)->Invert();
12496     } catch (std::out_of_range& e) {
12497       {
12498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12499       };
12500     } catch (std::exception& e) {
12501       {
12502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12503       };
12504     } catch (Dali::DaliException e) {
12505       {
12506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12507       };
12508     } catch (...) {
12509       {
12510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12511       };
12512     }
12513   }
12514
12515   jresult = result;
12516   return jresult;
12517 }
12518
12519
12520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12521   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12522
12523   arg1 = (Dali::Matrix *)jarg1;
12524   {
12525     try {
12526       (arg1)->Transpose();
12527     } catch (std::out_of_range& e) {
12528       {
12529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12530       };
12531     } catch (std::exception& e) {
12532       {
12533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12534       };
12535     } catch (Dali::DaliException e) {
12536       {
12537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12538       };
12539     } catch (...) {
12540       {
12541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12542       };
12543     }
12544   }
12545
12546 }
12547
12548
12549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12550   void * jresult ;
12551   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12552   Dali::Vector3 result;
12553
12554   arg1 = (Dali::Matrix *)jarg1;
12555   {
12556     try {
12557       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12558     } catch (std::out_of_range& e) {
12559       {
12560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12561       };
12562     } catch (std::exception& e) {
12563       {
12564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12565       };
12566     } catch (Dali::DaliException e) {
12567       {
12568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12569       };
12570     } catch (...) {
12571       {
12572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12573       };
12574     }
12575   }
12576
12577   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12578   return jresult;
12579 }
12580
12581
12582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12583   void * jresult ;
12584   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12585   Dali::Vector3 result;
12586
12587   arg1 = (Dali::Matrix *)jarg1;
12588   {
12589     try {
12590       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12591     } catch (std::out_of_range& e) {
12592       {
12593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12594       };
12595     } catch (std::exception& e) {
12596       {
12597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12598       };
12599     } catch (Dali::DaliException e) {
12600       {
12601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12602       };
12603     } catch (...) {
12604       {
12605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12606       };
12607     }
12608   }
12609
12610   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12611   return jresult;
12612 }
12613
12614
12615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12616   void * jresult ;
12617   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12618   Dali::Vector3 result;
12619
12620   arg1 = (Dali::Matrix *)jarg1;
12621   {
12622     try {
12623       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12624     } catch (std::out_of_range& e) {
12625       {
12626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12627       };
12628     } catch (std::exception& e) {
12629       {
12630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12631       };
12632     } catch (Dali::DaliException e) {
12633       {
12634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12635       };
12636     } catch (...) {
12637       {
12638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12639       };
12640     }
12641   }
12642
12643   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12644   return jresult;
12645 }
12646
12647
12648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12649   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12650   Dali::Vector3 *arg2 = 0 ;
12651
12652   arg1 = (Dali::Matrix *)jarg1;
12653   arg2 = (Dali::Vector3 *)jarg2;
12654   if (!arg2) {
12655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12656     return ;
12657   }
12658   {
12659     try {
12660       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12661     } catch (std::out_of_range& e) {
12662       {
12663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12664       };
12665     } catch (std::exception& e) {
12666       {
12667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12668       };
12669     } catch (Dali::DaliException e) {
12670       {
12671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12672       };
12673     } catch (...) {
12674       {
12675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12676       };
12677     }
12678   }
12679
12680 }
12681
12682
12683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12684   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12685   Dali::Vector3 *arg2 = 0 ;
12686
12687   arg1 = (Dali::Matrix *)jarg1;
12688   arg2 = (Dali::Vector3 *)jarg2;
12689   if (!arg2) {
12690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12691     return ;
12692   }
12693   {
12694     try {
12695       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12696     } catch (std::out_of_range& e) {
12697       {
12698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12699       };
12700     } catch (std::exception& e) {
12701       {
12702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12703       };
12704     } catch (Dali::DaliException e) {
12705       {
12706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12707       };
12708     } catch (...) {
12709       {
12710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12711       };
12712     }
12713   }
12714
12715 }
12716
12717
12718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12719   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12720   Dali::Vector3 *arg2 = 0 ;
12721
12722   arg1 = (Dali::Matrix *)jarg1;
12723   arg2 = (Dali::Vector3 *)jarg2;
12724   if (!arg2) {
12725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12726     return ;
12727   }
12728   {
12729     try {
12730       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12731     } catch (std::out_of_range& e) {
12732       {
12733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12734       };
12735     } catch (std::exception& e) {
12736       {
12737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12738       };
12739     } catch (Dali::DaliException e) {
12740       {
12741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12742       };
12743     } catch (...) {
12744       {
12745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12746       };
12747     }
12748   }
12749
12750 }
12751
12752
12753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12754   void * jresult ;
12755   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12756   Dali::Vector4 *result = 0 ;
12757
12758   arg1 = (Dali::Matrix *)jarg1;
12759   {
12760     try {
12761       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12762     } catch (std::out_of_range& e) {
12763       {
12764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12765       };
12766     } catch (std::exception& e) {
12767       {
12768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12769       };
12770     } catch (Dali::DaliException e) {
12771       {
12772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12773       };
12774     } catch (...) {
12775       {
12776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12777       };
12778     }
12779   }
12780
12781   jresult = (void *)result;
12782   return jresult;
12783 }
12784
12785
12786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12787   void * jresult ;
12788   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12789   Dali::Vector3 *result = 0 ;
12790
12791   arg1 = (Dali::Matrix *)jarg1;
12792   {
12793     try {
12794       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12795     } catch (std::out_of_range& e) {
12796       {
12797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12798       };
12799     } catch (std::exception& e) {
12800       {
12801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12802       };
12803     } catch (Dali::DaliException e) {
12804       {
12805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12806       };
12807     } catch (...) {
12808       {
12809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12810       };
12811     }
12812   }
12813
12814   jresult = (void *)result;
12815   return jresult;
12816 }
12817
12818
12819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12820   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12821   Dali::Vector4 *arg2 = 0 ;
12822
12823   arg1 = (Dali::Matrix *)jarg1;
12824   arg2 = (Dali::Vector4 *)jarg2;
12825   if (!arg2) {
12826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12827     return ;
12828   }
12829   {
12830     try {
12831       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12832     } catch (std::out_of_range& e) {
12833       {
12834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12835       };
12836     } catch (std::exception& e) {
12837       {
12838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12839       };
12840     } catch (Dali::DaliException e) {
12841       {
12842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12843       };
12844     } catch (...) {
12845       {
12846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12847       };
12848     }
12849   }
12850
12851 }
12852
12853
12854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12855   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12856   Dali::Vector3 *arg2 = 0 ;
12857
12858   arg1 = (Dali::Matrix *)jarg1;
12859   arg2 = (Dali::Vector3 *)jarg2;
12860   if (!arg2) {
12861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12862     return ;
12863   }
12864   {
12865     try {
12866       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12867     } catch (std::out_of_range& e) {
12868       {
12869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12870       };
12871     } catch (std::exception& e) {
12872       {
12873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12874       };
12875     } catch (Dali::DaliException e) {
12876       {
12877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12878       };
12879     } catch (...) {
12880       {
12881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12882       };
12883     }
12884   }
12885
12886 }
12887
12888
12889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12890   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12891
12892   arg1 = (Dali::Matrix *)jarg1;
12893   {
12894     try {
12895       (arg1)->OrthoNormalize();
12896     } catch (std::out_of_range& e) {
12897       {
12898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12899       };
12900     } catch (std::exception& e) {
12901       {
12902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12903       };
12904     } catch (Dali::DaliException e) {
12905       {
12906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12907       };
12908     } catch (...) {
12909       {
12910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12911       };
12912     }
12913   }
12914
12915 }
12916
12917
12918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12919   void * jresult ;
12920   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12921   float *result = 0 ;
12922
12923   arg1 = (Dali::Matrix *)jarg1;
12924   {
12925     try {
12926       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12927     } catch (std::out_of_range& e) {
12928       {
12929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12930       };
12931     } catch (std::exception& e) {
12932       {
12933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12934       };
12935     } catch (Dali::DaliException e) {
12936       {
12937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12938       };
12939     } catch (...) {
12940       {
12941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12942       };
12943     }
12944   }
12945
12946   jresult = (void *)result;
12947   return jresult;
12948 }
12949
12950
12951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12952   Dali::Matrix *arg1 = 0 ;
12953   Dali::Matrix *arg2 = 0 ;
12954   Dali::Matrix *arg3 = 0 ;
12955
12956   arg1 = (Dali::Matrix *)jarg1;
12957   if (!arg1) {
12958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12959     return ;
12960   }
12961   arg2 = (Dali::Matrix *)jarg2;
12962   if (!arg2) {
12963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12964     return ;
12965   }
12966   arg3 = (Dali::Matrix *)jarg3;
12967   if (!arg3) {
12968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12969     return ;
12970   }
12971   {
12972     try {
12973       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12974     } catch (std::out_of_range& e) {
12975       {
12976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12977       };
12978     } catch (std::exception& e) {
12979       {
12980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12981       };
12982     } catch (Dali::DaliException e) {
12983       {
12984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12985       };
12986     } catch (...) {
12987       {
12988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12989       };
12990     }
12991   }
12992
12993 }
12994
12995
12996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12997   Dali::Matrix *arg1 = 0 ;
12998   Dali::Matrix *arg2 = 0 ;
12999   Dali::Quaternion *arg3 = 0 ;
13000
13001   arg1 = (Dali::Matrix *)jarg1;
13002   if (!arg1) {
13003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13004     return ;
13005   }
13006   arg2 = (Dali::Matrix *)jarg2;
13007   if (!arg2) {
13008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13009     return ;
13010   }
13011   arg3 = (Dali::Quaternion *)jarg3;
13012   if (!arg3) {
13013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13014     return ;
13015   }
13016   {
13017     try {
13018       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13019     } catch (std::out_of_range& e) {
13020       {
13021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13022       };
13023     } catch (std::exception& e) {
13024       {
13025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13026       };
13027     } catch (Dali::DaliException e) {
13028       {
13029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13030       };
13031     } catch (...) {
13032       {
13033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13034       };
13035     }
13036   }
13037
13038 }
13039
13040
13041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13042   void * jresult ;
13043   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13044   Dali::Vector4 *arg2 = 0 ;
13045   Dali::Vector4 result;
13046
13047   arg1 = (Dali::Matrix *)jarg1;
13048   arg2 = (Dali::Vector4 *)jarg2;
13049   if (!arg2) {
13050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13051     return 0;
13052   }
13053   {
13054     try {
13055       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13056     } catch (std::out_of_range& e) {
13057       {
13058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13059       };
13060     } catch (std::exception& e) {
13061       {
13062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13063       };
13064     } catch (Dali::DaliException e) {
13065       {
13066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13067       };
13068     } catch (...) {
13069       {
13070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13071       };
13072     }
13073   }
13074
13075   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13076   return jresult;
13077 }
13078
13079
13080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13081   unsigned int jresult ;
13082   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13083   Dali::Matrix *arg2 = 0 ;
13084   bool result;
13085
13086   arg1 = (Dali::Matrix *)jarg1;
13087   arg2 = (Dali::Matrix *)jarg2;
13088   if (!arg2) {
13089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13090     return 0;
13091   }
13092   {
13093     try {
13094       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13095     } catch (std::out_of_range& e) {
13096       {
13097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13098       };
13099     } catch (std::exception& e) {
13100       {
13101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13102       };
13103     } catch (Dali::DaliException e) {
13104       {
13105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13106       };
13107     } catch (...) {
13108       {
13109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13110       };
13111     }
13112   }
13113
13114   jresult = result;
13115   return jresult;
13116 }
13117
13118
13119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13120   unsigned int jresult ;
13121   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13122   Dali::Matrix *arg2 = 0 ;
13123   bool result;
13124
13125   arg1 = (Dali::Matrix *)jarg1;
13126   arg2 = (Dali::Matrix *)jarg2;
13127   if (!arg2) {
13128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13129     return 0;
13130   }
13131   {
13132     try {
13133       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13134     } catch (std::out_of_range& e) {
13135       {
13136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13137       };
13138     } catch (std::exception& e) {
13139       {
13140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13141       };
13142     } catch (Dali::DaliException e) {
13143       {
13144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13145       };
13146     } catch (...) {
13147       {
13148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13149       };
13150     }
13151   }
13152
13153   jresult = result;
13154   return jresult;
13155 }
13156
13157
13158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13159   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13160   Dali::Vector3 *arg2 = 0 ;
13161   Dali::Quaternion *arg3 = 0 ;
13162   Dali::Vector3 *arg4 = 0 ;
13163
13164   arg1 = (Dali::Matrix *)jarg1;
13165   arg2 = (Dali::Vector3 *)jarg2;
13166   if (!arg2) {
13167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13168     return ;
13169   }
13170   arg3 = (Dali::Quaternion *)jarg3;
13171   if (!arg3) {
13172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13173     return ;
13174   }
13175   arg4 = (Dali::Vector3 *)jarg4;
13176   if (!arg4) {
13177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13178     return ;
13179   }
13180   {
13181     try {
13182       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13183     } catch (std::out_of_range& e) {
13184       {
13185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13186       };
13187     } catch (std::exception& e) {
13188       {
13189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13190       };
13191     } catch (Dali::DaliException e) {
13192       {
13193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13194       };
13195     } catch (...) {
13196       {
13197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13198       };
13199     }
13200   }
13201
13202 }
13203
13204
13205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13206   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13207   Dali::Vector3 *arg2 = 0 ;
13208   Dali::Quaternion *arg3 = 0 ;
13209   Dali::Vector3 *arg4 = 0 ;
13210
13211   arg1 = (Dali::Matrix *)jarg1;
13212   arg2 = (Dali::Vector3 *)jarg2;
13213   if (!arg2) {
13214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13215     return ;
13216   }
13217   arg3 = (Dali::Quaternion *)jarg3;
13218   if (!arg3) {
13219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13220     return ;
13221   }
13222   arg4 = (Dali::Vector3 *)jarg4;
13223   if (!arg4) {
13224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13225     return ;
13226   }
13227   {
13228     try {
13229       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13230     } catch (std::out_of_range& e) {
13231       {
13232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13233       };
13234     } catch (std::exception& e) {
13235       {
13236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13237       };
13238     } catch (Dali::DaliException e) {
13239       {
13240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13241       };
13242     } catch (...) {
13243       {
13244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13245       };
13246     }
13247   }
13248
13249 }
13250
13251
13252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13253   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13254   Dali::Vector3 *arg2 = 0 ;
13255   Dali::Vector3 *arg3 = 0 ;
13256   Dali::Vector3 *arg4 = 0 ;
13257   Dali::Vector3 *arg5 = 0 ;
13258
13259   arg1 = (Dali::Matrix *)jarg1;
13260   arg2 = (Dali::Vector3 *)jarg2;
13261   if (!arg2) {
13262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13263     return ;
13264   }
13265   arg3 = (Dali::Vector3 *)jarg3;
13266   if (!arg3) {
13267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13268     return ;
13269   }
13270   arg4 = (Dali::Vector3 *)jarg4;
13271   if (!arg4) {
13272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13273     return ;
13274   }
13275   arg5 = (Dali::Vector3 *)jarg5;
13276   if (!arg5) {
13277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13278     return ;
13279   }
13280   {
13281     try {
13282       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13283     } catch (std::out_of_range& e) {
13284       {
13285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13286       };
13287     } catch (std::exception& e) {
13288       {
13289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13290       };
13291     } catch (Dali::DaliException e) {
13292       {
13293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13294       };
13295     } catch (...) {
13296       {
13297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13298       };
13299     }
13300   }
13301
13302 }
13303
13304
13305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13306   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13307   Dali::Vector3 *arg2 = 0 ;
13308   Dali::Quaternion *arg3 = 0 ;
13309   Dali::Vector3 *arg4 = 0 ;
13310
13311   arg1 = (Dali::Matrix *)jarg1;
13312   arg2 = (Dali::Vector3 *)jarg2;
13313   if (!arg2) {
13314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13315     return ;
13316   }
13317   arg3 = (Dali::Quaternion *)jarg3;
13318   if (!arg3) {
13319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13320     return ;
13321   }
13322   arg4 = (Dali::Vector3 *)jarg4;
13323   if (!arg4) {
13324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13325     return ;
13326   }
13327   {
13328     try {
13329       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13330     } catch (std::out_of_range& e) {
13331       {
13332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13333       };
13334     } catch (std::exception& e) {
13335       {
13336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13337       };
13338     } catch (Dali::DaliException e) {
13339       {
13340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13341       };
13342     } catch (...) {
13343       {
13344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13345       };
13346     }
13347   }
13348
13349 }
13350
13351
13352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13353   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13354
13355   arg1 = (Dali::Matrix *)jarg1;
13356   {
13357     try {
13358       delete arg1;
13359     } catch (std::out_of_range& e) {
13360       {
13361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13362       };
13363     } catch (std::exception& e) {
13364       {
13365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13366       };
13367     } catch (Dali::DaliException e) {
13368       {
13369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13370       };
13371     } catch (...) {
13372       {
13373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13374       };
13375     }
13376   }
13377
13378 }
13379
13380
13381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13382   void * jresult ;
13383   Dali::Matrix3 *result = 0 ;
13384
13385   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13386   jresult = (void *)result;
13387   return jresult;
13388 }
13389
13390
13391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13392   void * jresult ;
13393   Dali::Matrix3 *result = 0 ;
13394
13395   {
13396     try {
13397       result = (Dali::Matrix3 *)new Dali::Matrix3();
13398     } catch (std::out_of_range& e) {
13399       {
13400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13401       };
13402     } catch (std::exception& e) {
13403       {
13404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13405       };
13406     } catch (Dali::DaliException e) {
13407       {
13408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13409       };
13410     } catch (...) {
13411       {
13412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13413       };
13414     }
13415   }
13416
13417   jresult = (void *)result;
13418   return jresult;
13419 }
13420
13421
13422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13423   void * jresult ;
13424   Dali::Matrix3 *arg1 = 0 ;
13425   Dali::Matrix3 *result = 0 ;
13426
13427   arg1 = (Dali::Matrix3 *)jarg1;
13428   if (!arg1) {
13429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13430     return 0;
13431   }
13432   {
13433     try {
13434       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13435     } catch (std::out_of_range& e) {
13436       {
13437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13438       };
13439     } catch (std::exception& e) {
13440       {
13441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13442       };
13443     } catch (Dali::DaliException e) {
13444       {
13445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13446       };
13447     } catch (...) {
13448       {
13449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13450       };
13451     }
13452   }
13453
13454   jresult = (void *)result;
13455   return jresult;
13456 }
13457
13458
13459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13460   void * jresult ;
13461   Dali::Matrix *arg1 = 0 ;
13462   Dali::Matrix3 *result = 0 ;
13463
13464   arg1 = (Dali::Matrix *)jarg1;
13465   if (!arg1) {
13466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13467     return 0;
13468   }
13469   {
13470     try {
13471       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13472     } catch (std::out_of_range& e) {
13473       {
13474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13475       };
13476     } catch (std::exception& e) {
13477       {
13478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13479       };
13480     } catch (Dali::DaliException e) {
13481       {
13482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13483       };
13484     } catch (...) {
13485       {
13486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13487       };
13488     }
13489   }
13490
13491   jresult = (void *)result;
13492   return jresult;
13493 }
13494
13495
13496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
13497   void * jresult ;
13498   float arg1 ;
13499   float arg2 ;
13500   float arg3 ;
13501   float arg4 ;
13502   float arg5 ;
13503   float arg6 ;
13504   float arg7 ;
13505   float arg8 ;
13506   float arg9 ;
13507   Dali::Matrix3 *result = 0 ;
13508
13509   arg1 = (float)jarg1;
13510   arg2 = (float)jarg2;
13511   arg3 = (float)jarg3;
13512   arg4 = (float)jarg4;
13513   arg5 = (float)jarg5;
13514   arg6 = (float)jarg6;
13515   arg7 = (float)jarg7;
13516   arg8 = (float)jarg8;
13517   arg9 = (float)jarg9;
13518   {
13519     try {
13520       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13521     } catch (std::out_of_range& e) {
13522       {
13523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13524       };
13525     } catch (std::exception& e) {
13526       {
13527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13528       };
13529     } catch (Dali::DaliException e) {
13530       {
13531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13532       };
13533     } catch (...) {
13534       {
13535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13536       };
13537     }
13538   }
13539
13540   jresult = (void *)result;
13541   return jresult;
13542 }
13543
13544
13545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13546   void * jresult ;
13547   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13548   Dali::Matrix3 *arg2 = 0 ;
13549   Dali::Matrix3 *result = 0 ;
13550
13551   arg1 = (Dali::Matrix3 *)jarg1;
13552   arg2 = (Dali::Matrix3 *)jarg2;
13553   if (!arg2) {
13554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13555     return 0;
13556   }
13557   {
13558     try {
13559       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13560     } catch (std::out_of_range& e) {
13561       {
13562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13563       };
13564     } catch (std::exception& e) {
13565       {
13566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13567       };
13568     } catch (Dali::DaliException e) {
13569       {
13570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13571       };
13572     } catch (...) {
13573       {
13574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13575       };
13576     }
13577   }
13578
13579   jresult = (void *)result;
13580   return jresult;
13581 }
13582
13583
13584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13585   void * jresult ;
13586   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13587   Dali::Matrix *arg2 = 0 ;
13588   Dali::Matrix3 *result = 0 ;
13589
13590   arg1 = (Dali::Matrix3 *)jarg1;
13591   arg2 = (Dali::Matrix *)jarg2;
13592   if (!arg2) {
13593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13594     return 0;
13595   }
13596   {
13597     try {
13598       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13599     } catch (std::out_of_range& e) {
13600       {
13601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13602       };
13603     } catch (std::exception& e) {
13604       {
13605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13606       };
13607     } catch (Dali::DaliException e) {
13608       {
13609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13610       };
13611     } catch (...) {
13612       {
13613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13614       };
13615     }
13616   }
13617
13618   jresult = (void *)result;
13619   return jresult;
13620 }
13621
13622
13623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13624   unsigned int jresult ;
13625   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13626   Dali::Matrix3 *arg2 = 0 ;
13627   bool result;
13628
13629   arg1 = (Dali::Matrix3 *)jarg1;
13630   arg2 = (Dali::Matrix3 *)jarg2;
13631   if (!arg2) {
13632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13633     return 0;
13634   }
13635   {
13636     try {
13637       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13638     } catch (std::out_of_range& e) {
13639       {
13640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13641       };
13642     } catch (std::exception& e) {
13643       {
13644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13645       };
13646     } catch (Dali::DaliException e) {
13647       {
13648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13649       };
13650     } catch (...) {
13651       {
13652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13653       };
13654     }
13655   }
13656
13657   jresult = result;
13658   return jresult;
13659 }
13660
13661
13662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13663   unsigned int jresult ;
13664   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13665   Dali::Matrix3 *arg2 = 0 ;
13666   bool result;
13667
13668   arg1 = (Dali::Matrix3 *)jarg1;
13669   arg2 = (Dali::Matrix3 *)jarg2;
13670   if (!arg2) {
13671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13672     return 0;
13673   }
13674   {
13675     try {
13676       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13677     } catch (std::out_of_range& e) {
13678       {
13679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13680       };
13681     } catch (std::exception& e) {
13682       {
13683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13684       };
13685     } catch (Dali::DaliException e) {
13686       {
13687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13688       };
13689     } catch (...) {
13690       {
13691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13692       };
13693     }
13694   }
13695
13696   jresult = result;
13697   return jresult;
13698 }
13699
13700
13701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13702   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13703
13704   arg1 = (Dali::Matrix3 *)jarg1;
13705   {
13706     try {
13707       delete arg1;
13708     } catch (std::out_of_range& e) {
13709       {
13710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13711       };
13712     } catch (std::exception& e) {
13713       {
13714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13715       };
13716     } catch (Dali::DaliException e) {
13717       {
13718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13719       };
13720     } catch (...) {
13721       {
13722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13723       };
13724     }
13725   }
13726
13727 }
13728
13729
13730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13731   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13732
13733   arg1 = (Dali::Matrix3 *)jarg1;
13734   {
13735     try {
13736       (arg1)->SetIdentity();
13737     } catch (std::out_of_range& e) {
13738       {
13739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13740       };
13741     } catch (std::exception& e) {
13742       {
13743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13744       };
13745     } catch (Dali::DaliException e) {
13746       {
13747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13748       };
13749     } catch (...) {
13750       {
13751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13752       };
13753     }
13754   }
13755
13756 }
13757
13758
13759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13760   void * jresult ;
13761   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13762   float *result = 0 ;
13763
13764   arg1 = (Dali::Matrix3 *)jarg1;
13765   {
13766     try {
13767       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13768     } catch (std::out_of_range& e) {
13769       {
13770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13771       };
13772     } catch (std::exception& e) {
13773       {
13774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13775       };
13776     } catch (Dali::DaliException e) {
13777       {
13778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13779       };
13780     } catch (...) {
13781       {
13782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13783       };
13784     }
13785   }
13786
13787   jresult = (void *)result;
13788   return jresult;
13789 }
13790
13791
13792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13793   unsigned int jresult ;
13794   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13795   bool result;
13796
13797   arg1 = (Dali::Matrix3 *)jarg1;
13798   {
13799     try {
13800       result = (bool)(arg1)->Invert();
13801     } catch (std::out_of_range& e) {
13802       {
13803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13804       };
13805     } catch (std::exception& e) {
13806       {
13807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13808       };
13809     } catch (Dali::DaliException e) {
13810       {
13811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13812       };
13813     } catch (...) {
13814       {
13815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13816       };
13817     }
13818   }
13819
13820   jresult = result;
13821   return jresult;
13822 }
13823
13824
13825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13826   unsigned int jresult ;
13827   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13828   bool result;
13829
13830   arg1 = (Dali::Matrix3 *)jarg1;
13831   {
13832     try {
13833       result = (bool)(arg1)->Transpose();
13834     } catch (std::out_of_range& e) {
13835       {
13836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13837       };
13838     } catch (std::exception& e) {
13839       {
13840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13841       };
13842     } catch (Dali::DaliException e) {
13843       {
13844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13845       };
13846     } catch (...) {
13847       {
13848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13849       };
13850     }
13851   }
13852
13853   jresult = result;
13854   return jresult;
13855 }
13856
13857
13858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13859   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13860   float arg2 ;
13861
13862   arg1 = (Dali::Matrix3 *)jarg1;
13863   arg2 = (float)jarg2;
13864   {
13865     try {
13866       (arg1)->Scale(arg2);
13867     } catch (std::out_of_range& e) {
13868       {
13869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13870       };
13871     } catch (std::exception& e) {
13872       {
13873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13874       };
13875     } catch (Dali::DaliException e) {
13876       {
13877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13878       };
13879     } catch (...) {
13880       {
13881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13882       };
13883     }
13884   }
13885
13886 }
13887
13888
13889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13890   float jresult ;
13891   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13892   float result;
13893
13894   arg1 = (Dali::Matrix3 *)jarg1;
13895   {
13896     try {
13897       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13898     } catch (std::out_of_range& e) {
13899       {
13900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13901       };
13902     } catch (std::exception& e) {
13903       {
13904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13905       };
13906     } catch (Dali::DaliException e) {
13907       {
13908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13909       };
13910     } catch (...) {
13911       {
13912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13913       };
13914     }
13915   }
13916
13917   jresult = result;
13918   return jresult;
13919 }
13920
13921
13922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13923   unsigned int jresult ;
13924   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13925   bool result;
13926
13927   arg1 = (Dali::Matrix3 *)jarg1;
13928   {
13929     try {
13930       result = (bool)(arg1)->ScaledInverseTranspose();
13931     } catch (std::out_of_range& e) {
13932       {
13933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13934       };
13935     } catch (std::exception& e) {
13936       {
13937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13938       };
13939     } catch (Dali::DaliException e) {
13940       {
13941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13942       };
13943     } catch (...) {
13944       {
13945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13946       };
13947     }
13948   }
13949
13950   jresult = result;
13951   return jresult;
13952 }
13953
13954
13955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13956   Dali::Matrix3 *arg1 = 0 ;
13957   Dali::Matrix3 *arg2 = 0 ;
13958   Dali::Matrix3 *arg3 = 0 ;
13959
13960   arg1 = (Dali::Matrix3 *)jarg1;
13961   if (!arg1) {
13962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13963     return ;
13964   }
13965   arg2 = (Dali::Matrix3 *)jarg2;
13966   if (!arg2) {
13967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13968     return ;
13969   }
13970   arg3 = (Dali::Matrix3 *)jarg3;
13971   if (!arg3) {
13972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13973     return ;
13974   }
13975   {
13976     try {
13977       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13978     } catch (std::out_of_range& e) {
13979       {
13980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13981       };
13982     } catch (std::exception& e) {
13983       {
13984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13985       };
13986     } catch (Dali::DaliException e) {
13987       {
13988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13989       };
13990     } catch (...) {
13991       {
13992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13993       };
13994     }
13995   }
13996
13997 }
13998
13999
14000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14001   float jresult ;
14002   float arg1 ;
14003   float arg2 ;
14004   float result;
14005
14006   arg1 = (float)jarg1;
14007   arg2 = (float)jarg2;
14008   {
14009     try {
14010       result = (float)Dali::Random::Range(arg1,arg2);
14011     } catch (std::out_of_range& e) {
14012       {
14013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14014       };
14015     } catch (std::exception& e) {
14016       {
14017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14018       };
14019     } catch (Dali::DaliException e) {
14020       {
14021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14022       };
14023     } catch (...) {
14024       {
14025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14026       };
14027     }
14028   }
14029
14030   jresult = result;
14031   return jresult;
14032 }
14033
14034
14035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14036   void * jresult ;
14037   Dali::Vector4 result;
14038
14039   {
14040     try {
14041       result = Dali::Random::Axis();
14042     } catch (std::out_of_range& e) {
14043       {
14044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14045       };
14046     } catch (std::exception& e) {
14047       {
14048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14049       };
14050     } catch (Dali::DaliException e) {
14051       {
14052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14053       };
14054     } catch (...) {
14055       {
14056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14057       };
14058     }
14059   }
14060
14061   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14062   return jresult;
14063 }
14064
14065
14066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14067   void * jresult ;
14068   Dali::AngleAxis *result = 0 ;
14069
14070   {
14071     try {
14072       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14073     } catch (std::out_of_range& e) {
14074       {
14075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14076       };
14077     } catch (std::exception& e) {
14078       {
14079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14080       };
14081     } catch (Dali::DaliException e) {
14082       {
14083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14084       };
14085     } catch (...) {
14086       {
14087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14088       };
14089     }
14090   }
14091
14092   jresult = (void *)result;
14093   return jresult;
14094 }
14095
14096
14097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14098   void * jresult ;
14099   Dali::Radian arg1 ;
14100   Dali::Vector3 *arg2 = 0 ;
14101   Dali::Radian *argp1 ;
14102   Dali::AngleAxis *result = 0 ;
14103
14104   argp1 = (Dali::Radian *)jarg1;
14105   if (!argp1) {
14106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14107     return 0;
14108   }
14109   arg1 = *argp1;
14110   arg2 = (Dali::Vector3 *)jarg2;
14111   if (!arg2) {
14112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14113     return 0;
14114   }
14115   {
14116     try {
14117       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14118     } catch (std::out_of_range& e) {
14119       {
14120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14121       };
14122     } catch (std::exception& e) {
14123       {
14124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14125       };
14126     } catch (Dali::DaliException e) {
14127       {
14128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14129       };
14130     } catch (...) {
14131       {
14132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14133       };
14134     }
14135   }
14136
14137   jresult = (void *)result;
14138   return jresult;
14139 }
14140
14141
14142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14143   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14144   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14145
14146   arg1 = (Dali::AngleAxis *)jarg1;
14147   arg2 = (Dali::Radian *)jarg2;
14148   if (arg1) (arg1)->angle = *arg2;
14149 }
14150
14151
14152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14153   void * jresult ;
14154   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14155   Dali::Radian *result = 0 ;
14156
14157   arg1 = (Dali::AngleAxis *)jarg1;
14158   result = (Dali::Radian *)& ((arg1)->angle);
14159   jresult = (void *)result;
14160   return jresult;
14161 }
14162
14163
14164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14165   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14166   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14167
14168   arg1 = (Dali::AngleAxis *)jarg1;
14169   arg2 = (Dali::Vector3 *)jarg2;
14170   if (arg1) (arg1)->axis = *arg2;
14171 }
14172
14173
14174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14175   void * jresult ;
14176   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14177   Dali::Vector3 *result = 0 ;
14178
14179   arg1 = (Dali::AngleAxis *)jarg1;
14180   result = (Dali::Vector3 *)& ((arg1)->axis);
14181   jresult = (void *)result;
14182   return jresult;
14183 }
14184
14185
14186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14187   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14188
14189   arg1 = (Dali::AngleAxis *)jarg1;
14190   {
14191     try {
14192       delete arg1;
14193     } catch (std::out_of_range& e) {
14194       {
14195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14196       };
14197     } catch (std::exception& e) {
14198       {
14199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14200       };
14201     } catch (Dali::DaliException e) {
14202       {
14203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14204       };
14205     } catch (...) {
14206       {
14207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14208       };
14209     }
14210   }
14211
14212 }
14213
14214
14215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14216   unsigned int jresult ;
14217   Dali::AngleAxis *arg1 = 0 ;
14218   Dali::AngleAxis *arg2 = 0 ;
14219   bool result;
14220
14221   arg1 = (Dali::AngleAxis *)jarg1;
14222   if (!arg1) {
14223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14224     return 0;
14225   }
14226   arg2 = (Dali::AngleAxis *)jarg2;
14227   if (!arg2) {
14228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14229     return 0;
14230   }
14231   {
14232     try {
14233       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14234     } catch (std::out_of_range& e) {
14235       {
14236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14237       };
14238     } catch (std::exception& e) {
14239       {
14240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14241       };
14242     } catch (Dali::DaliException e) {
14243       {
14244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14245       };
14246     } catch (...) {
14247       {
14248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14249       };
14250     }
14251   }
14252
14253   jresult = result;
14254   return jresult;
14255 }
14256
14257
14258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14259   unsigned int jresult ;
14260   unsigned int arg1 ;
14261   unsigned int result;
14262
14263   arg1 = (unsigned int)jarg1;
14264   {
14265     try {
14266       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14267     } catch (std::out_of_range& e) {
14268       {
14269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14270       };
14271     } catch (std::exception& e) {
14272       {
14273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14274       };
14275     } catch (Dali::DaliException e) {
14276       {
14277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14278       };
14279     } catch (...) {
14280       {
14281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14282       };
14283     }
14284   }
14285
14286   jresult = result;
14287   return jresult;
14288 }
14289
14290
14291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14292   unsigned int jresult ;
14293   unsigned int arg1 ;
14294   bool result;
14295
14296   arg1 = (unsigned int)jarg1;
14297   {
14298     try {
14299       result = (bool)Dali::IsPowerOfTwo(arg1);
14300     } catch (std::out_of_range& e) {
14301       {
14302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14303       };
14304     } catch (std::exception& e) {
14305       {
14306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14307       };
14308     } catch (Dali::DaliException e) {
14309       {
14310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14311       };
14312     } catch (...) {
14313       {
14314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14315       };
14316     }
14317   }
14318
14319   jresult = result;
14320   return jresult;
14321 }
14322
14323
14324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14325   float jresult ;
14326   float arg1 ;
14327   float arg2 ;
14328   float result;
14329
14330   arg1 = (float)jarg1;
14331   arg2 = (float)jarg2;
14332   {
14333     try {
14334       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14335     } catch (std::out_of_range& e) {
14336       {
14337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14338       };
14339     } catch (std::exception& e) {
14340       {
14341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14342       };
14343     } catch (Dali::DaliException e) {
14344       {
14345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14346       };
14347     } catch (...) {
14348       {
14349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14350       };
14351     }
14352   }
14353
14354   jresult = result;
14355   return jresult;
14356 }
14357
14358
14359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14360   unsigned int jresult ;
14361   float arg1 ;
14362   bool result;
14363
14364   arg1 = (float)jarg1;
14365   {
14366     try {
14367       result = (bool)Dali::EqualsZero(arg1);
14368     } catch (std::out_of_range& e) {
14369       {
14370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14371       };
14372     } catch (std::exception& e) {
14373       {
14374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14375       };
14376     } catch (Dali::DaliException e) {
14377       {
14378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14379       };
14380     } catch (...) {
14381       {
14382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14383       };
14384     }
14385   }
14386
14387   jresult = result;
14388   return jresult;
14389 }
14390
14391
14392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14393   unsigned int jresult ;
14394   float arg1 ;
14395   float arg2 ;
14396   bool result;
14397
14398   arg1 = (float)jarg1;
14399   arg2 = (float)jarg2;
14400   {
14401     try {
14402       result = (bool)Dali::Equals(arg1,arg2);
14403     } catch (std::out_of_range& e) {
14404       {
14405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14406       };
14407     } catch (std::exception& e) {
14408       {
14409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14410       };
14411     } catch (Dali::DaliException e) {
14412       {
14413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14414       };
14415     } catch (...) {
14416       {
14417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14418       };
14419     }
14420   }
14421
14422   jresult = result;
14423   return jresult;
14424 }
14425
14426
14427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14428   unsigned int jresult ;
14429   float arg1 ;
14430   float arg2 ;
14431   float arg3 ;
14432   bool result;
14433
14434   arg1 = (float)jarg1;
14435   arg2 = (float)jarg2;
14436   arg3 = (float)jarg3;
14437   {
14438     try {
14439       result = (bool)Dali::Equals(arg1,arg2,arg3);
14440     } catch (std::out_of_range& e) {
14441       {
14442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14443       };
14444     } catch (std::exception& e) {
14445       {
14446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14447       };
14448     } catch (Dali::DaliException e) {
14449       {
14450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14451       };
14452     } catch (...) {
14453       {
14454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14455       };
14456     }
14457   }
14458
14459   jresult = result;
14460   return jresult;
14461 }
14462
14463
14464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14465   float jresult ;
14466   float arg1 ;
14467   int arg2 ;
14468   float result;
14469
14470   arg1 = (float)jarg1;
14471   arg2 = (int)jarg2;
14472   {
14473     try {
14474       result = (float)Dali::Round(arg1,arg2);
14475     } catch (std::out_of_range& e) {
14476       {
14477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14478       };
14479     } catch (std::exception& e) {
14480       {
14481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14482       };
14483     } catch (Dali::DaliException e) {
14484       {
14485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14486       };
14487     } catch (...) {
14488       {
14489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14490       };
14491     }
14492   }
14493
14494   jresult = result;
14495   return jresult;
14496 }
14497
14498
14499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14500   float jresult ;
14501   float arg1 ;
14502   float arg2 ;
14503   float arg3 ;
14504   float result;
14505
14506   arg1 = (float)jarg1;
14507   arg2 = (float)jarg2;
14508   arg3 = (float)jarg3;
14509   {
14510     try {
14511       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14512     } catch (std::out_of_range& e) {
14513       {
14514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14515       };
14516     } catch (std::exception& e) {
14517       {
14518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14519       };
14520     } catch (Dali::DaliException e) {
14521       {
14522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14523       };
14524     } catch (...) {
14525       {
14526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14527       };
14528     }
14529   }
14530
14531   jresult = result;
14532   return jresult;
14533 }
14534
14535
14536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14537   float jresult ;
14538   float arg1 ;
14539   float arg2 ;
14540   float arg3 ;
14541   float arg4 ;
14542   float result;
14543
14544   arg1 = (float)jarg1;
14545   arg2 = (float)jarg2;
14546   arg3 = (float)jarg3;
14547   arg4 = (float)jarg4;
14548   {
14549     try {
14550       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14551     } catch (std::out_of_range& e) {
14552       {
14553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14554       };
14555     } catch (std::exception& e) {
14556       {
14557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14558       };
14559     } catch (Dali::DaliException e) {
14560       {
14561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14562       };
14563     } catch (...) {
14564       {
14565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14566       };
14567     }
14568   }
14569
14570   jresult = result;
14571   return jresult;
14572 }
14573
14574
14575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14576   int jresult ;
14577   int result;
14578
14579   result = (int)(int)Dali::Property::INVALID_INDEX;
14580   jresult = result;
14581   return jresult;
14582 }
14583
14584
14585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14586   int jresult ;
14587   int result;
14588
14589   result = (int)(int)Dali::Property::INVALID_KEY;
14590   jresult = result;
14591   return jresult;
14592 }
14593
14594
14595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14596   int jresult ;
14597   int result;
14598
14599   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14600   jresult = result;
14601   return jresult;
14602 }
14603
14604
14605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14606   void * jresult ;
14607   Dali::Handle *arg1 = 0 ;
14608   Dali::Property::Index arg2 ;
14609   Dali::Property *result = 0 ;
14610
14611   arg1 = (Dali::Handle *)jarg1;
14612   if (!arg1) {
14613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14614     return 0;
14615   }
14616   arg2 = (Dali::Property::Index)jarg2;
14617   {
14618     try {
14619       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14620     } catch (std::out_of_range& e) {
14621       {
14622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14623       };
14624     } catch (std::exception& e) {
14625       {
14626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14627       };
14628     } catch (Dali::DaliException e) {
14629       {
14630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14631       };
14632     } catch (...) {
14633       {
14634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14635       };
14636     }
14637   }
14638
14639   jresult = (void *)result;
14640   return jresult;
14641 }
14642
14643
14644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14645   void * jresult ;
14646   Dali::Handle *arg1 = 0 ;
14647   Dali::Property::Index arg2 ;
14648   int arg3 ;
14649   Dali::Property *result = 0 ;
14650
14651   arg1 = (Dali::Handle *)jarg1;
14652   if (!arg1) {
14653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14654     return 0;
14655   }
14656   arg2 = (Dali::Property::Index)jarg2;
14657   arg3 = (int)jarg3;
14658   {
14659     try {
14660       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14661     } catch (std::out_of_range& e) {
14662       {
14663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14664       };
14665     } catch (std::exception& e) {
14666       {
14667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14668       };
14669     } catch (Dali::DaliException e) {
14670       {
14671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14672       };
14673     } catch (...) {
14674       {
14675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14676       };
14677     }
14678   }
14679
14680   jresult = (void *)result;
14681   return jresult;
14682 }
14683
14684
14685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14686   void * jresult ;
14687   Dali::Handle *arg1 = 0 ;
14688   std::string *arg2 = 0 ;
14689   Dali::Property *result = 0 ;
14690
14691   arg1 = (Dali::Handle *)jarg1;
14692   if (!arg1) {
14693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14694     return 0;
14695   }
14696   if (!jarg2) {
14697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14698     return 0;
14699   }
14700   std::string arg2_str(jarg2);
14701   arg2 = &arg2_str;
14702   {
14703     try {
14704       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14705     } catch (std::out_of_range& e) {
14706       {
14707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14708       };
14709     } catch (std::exception& e) {
14710       {
14711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14712       };
14713     } catch (Dali::DaliException e) {
14714       {
14715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14716       };
14717     } catch (...) {
14718       {
14719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14720       };
14721     }
14722   }
14723
14724   jresult = (void *)result;
14725
14726   //argout typemap for const std::string&
14727
14728   return jresult;
14729 }
14730
14731
14732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14733   void * jresult ;
14734   Dali::Handle *arg1 = 0 ;
14735   std::string *arg2 = 0 ;
14736   int arg3 ;
14737   Dali::Property *result = 0 ;
14738
14739   arg1 = (Dali::Handle *)jarg1;
14740   if (!arg1) {
14741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14742     return 0;
14743   }
14744   if (!jarg2) {
14745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14746     return 0;
14747   }
14748   std::string arg2_str(jarg2);
14749   arg2 = &arg2_str;
14750   arg3 = (int)jarg3;
14751   {
14752     try {
14753       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14754     } catch (std::out_of_range& e) {
14755       {
14756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14757       };
14758     } catch (std::exception& e) {
14759       {
14760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14761       };
14762     } catch (Dali::DaliException e) {
14763       {
14764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14765       };
14766     } catch (...) {
14767       {
14768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14769       };
14770     }
14771   }
14772
14773   jresult = (void *)result;
14774
14775   //argout typemap for const std::string&
14776
14777   return jresult;
14778 }
14779
14780
14781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14782   Dali::Property *arg1 = (Dali::Property *) 0 ;
14783
14784   arg1 = (Dali::Property *)jarg1;
14785   {
14786     try {
14787       delete arg1;
14788     } catch (std::out_of_range& e) {
14789       {
14790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14791       };
14792     } catch (std::exception& e) {
14793       {
14794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14795       };
14796     } catch (Dali::DaliException e) {
14797       {
14798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14799       };
14800     } catch (...) {
14801       {
14802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14803       };
14804     }
14805   }
14806
14807 }
14808
14809
14810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14811   Dali::Property *arg1 = (Dali::Property *) 0 ;
14812   Dali::Handle *arg2 = 0 ;
14813
14814   arg1 = (Dali::Property *)jarg1;
14815   arg2 = (Dali::Handle *)jarg2;
14816   if (!arg2) {
14817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14818     return ;
14819   }
14820   if (arg1) (arg1)->object = *arg2;
14821 }
14822
14823
14824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14825   void * jresult ;
14826   Dali::Property *arg1 = (Dali::Property *) 0 ;
14827   Dali::Handle *result = 0 ;
14828
14829   arg1 = (Dali::Property *)jarg1;
14830   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14831   jresult = (void *)result;
14832   return jresult;
14833 }
14834
14835
14836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14837   Dali::Property *arg1 = (Dali::Property *) 0 ;
14838   Dali::Property::Index arg2 ;
14839
14840   arg1 = (Dali::Property *)jarg1;
14841   arg2 = (Dali::Property::Index)jarg2;
14842   if (arg1) (arg1)->propertyIndex = arg2;
14843 }
14844
14845
14846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14847   int jresult ;
14848   Dali::Property *arg1 = (Dali::Property *) 0 ;
14849   Dali::Property::Index result;
14850
14851   arg1 = (Dali::Property *)jarg1;
14852   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14853   jresult = result;
14854   return jresult;
14855 }
14856
14857
14858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14859   Dali::Property *arg1 = (Dali::Property *) 0 ;
14860   int arg2 ;
14861
14862   arg1 = (Dali::Property *)jarg1;
14863   arg2 = (int)jarg2;
14864   if (arg1) (arg1)->componentIndex = arg2;
14865 }
14866
14867
14868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14869   int jresult ;
14870   Dali::Property *arg1 = (Dali::Property *) 0 ;
14871   int result;
14872
14873   arg1 = (Dali::Property *)jarg1;
14874   result = (int) ((arg1)->componentIndex);
14875   jresult = result;
14876   return jresult;
14877 }
14878
14879
14880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14881   void * jresult ;
14882   Dali::Property::Array *result = 0 ;
14883
14884   {
14885     try {
14886       result = (Dali::Property::Array *)new Dali::Property::Array();
14887     } catch (std::out_of_range& e) {
14888       {
14889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14890       };
14891     } catch (std::exception& e) {
14892       {
14893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14894       };
14895     } catch (Dali::DaliException e) {
14896       {
14897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14898       };
14899     } catch (...) {
14900       {
14901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14902       };
14903     }
14904   }
14905
14906   jresult = (void *)result;
14907   return jresult;
14908 }
14909
14910
14911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14912   void * jresult ;
14913   Dali::Property::Array *arg1 = 0 ;
14914   Dali::Property::Array *result = 0 ;
14915
14916   arg1 = (Dali::Property::Array *)jarg1;
14917   if (!arg1) {
14918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14919     return 0;
14920   }
14921   {
14922     try {
14923       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14924     } catch (std::out_of_range& e) {
14925       {
14926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14927       };
14928     } catch (std::exception& e) {
14929       {
14930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14931       };
14932     } catch (Dali::DaliException e) {
14933       {
14934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14935       };
14936     } catch (...) {
14937       {
14938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14939       };
14940     }
14941   }
14942
14943   jresult = (void *)result;
14944   return jresult;
14945 }
14946
14947
14948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14949   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14950
14951   arg1 = (Dali::Property::Array *)jarg1;
14952   {
14953     try {
14954       delete arg1;
14955     } catch (std::out_of_range& e) {
14956       {
14957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14958       };
14959     } catch (std::exception& e) {
14960       {
14961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14962       };
14963     } catch (Dali::DaliException e) {
14964       {
14965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14966       };
14967     } catch (...) {
14968       {
14969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14970       };
14971     }
14972   }
14973
14974 }
14975
14976
14977 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14978   unsigned long jresult ;
14979   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14980   Dali::Property::Array::SizeType result;
14981
14982   arg1 = (Dali::Property::Array *)jarg1;
14983   {
14984     try {
14985       result = ((Dali::Property::Array const *)arg1)->Size();
14986     } catch (std::out_of_range& e) {
14987       {
14988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14989       };
14990     } catch (std::exception& e) {
14991       {
14992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14993       };
14994     } catch (Dali::DaliException e) {
14995       {
14996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14997       };
14998     } catch (...) {
14999       {
15000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15001       };
15002     }
15003   }
15004
15005   jresult = (unsigned long)result;
15006   return jresult;
15007 }
15008
15009
15010 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15011   unsigned long jresult ;
15012   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15013   Dali::Property::Array::SizeType result;
15014
15015   arg1 = (Dali::Property::Array *)jarg1;
15016   {
15017     try {
15018       result = ((Dali::Property::Array const *)arg1)->Count();
15019     } catch (std::out_of_range& e) {
15020       {
15021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15022       };
15023     } catch (std::exception& e) {
15024       {
15025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15026       };
15027     } catch (Dali::DaliException e) {
15028       {
15029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15030       };
15031     } catch (...) {
15032       {
15033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15034       };
15035     }
15036   }
15037
15038   jresult = (unsigned long)result;
15039   return jresult;
15040 }
15041
15042
15043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15044   unsigned int jresult ;
15045   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15046   bool result;
15047
15048   arg1 = (Dali::Property::Array *)jarg1;
15049   {
15050     try {
15051       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15052     } catch (std::out_of_range& e) {
15053       {
15054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15055       };
15056     } catch (std::exception& e) {
15057       {
15058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15059       };
15060     } catch (Dali::DaliException e) {
15061       {
15062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15063       };
15064     } catch (...) {
15065       {
15066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15067       };
15068     }
15069   }
15070
15071   jresult = result;
15072   return jresult;
15073 }
15074
15075
15076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15077   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15078
15079   arg1 = (Dali::Property::Array *)jarg1;
15080   {
15081     try {
15082       (arg1)->Clear();
15083     } catch (std::out_of_range& e) {
15084       {
15085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15086       };
15087     } catch (std::exception& e) {
15088       {
15089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15090       };
15091     } catch (Dali::DaliException e) {
15092       {
15093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15094       };
15095     } catch (...) {
15096       {
15097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15098       };
15099     }
15100   }
15101
15102 }
15103
15104
15105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15106   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15107   Dali::Property::Array::SizeType arg2 ;
15108
15109   arg1 = (Dali::Property::Array *)jarg1;
15110   arg2 = (Dali::Property::Array::SizeType)jarg2;
15111   {
15112     try {
15113       (arg1)->Reserve(arg2);
15114     } catch (std::out_of_range& e) {
15115       {
15116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15117       };
15118     } catch (std::exception& e) {
15119       {
15120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15121       };
15122     } catch (Dali::DaliException e) {
15123       {
15124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15125       };
15126     } catch (...) {
15127       {
15128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15129       };
15130     }
15131   }
15132
15133 }
15134
15135
15136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15137   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15138   Dali::Property::Array::SizeType arg2 ;
15139
15140   arg1 = (Dali::Property::Array *)jarg1;
15141   arg2 = (Dali::Property::Array::SizeType)jarg2;
15142   {
15143     try {
15144       (arg1)->Resize(arg2);
15145     } catch (std::out_of_range& e) {
15146       {
15147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15148       };
15149     } catch (std::exception& e) {
15150       {
15151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15152       };
15153     } catch (Dali::DaliException e) {
15154       {
15155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15156       };
15157     } catch (...) {
15158       {
15159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15160       };
15161     }
15162   }
15163
15164 }
15165
15166
15167 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15168   unsigned long jresult ;
15169   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15170   Dali::Property::Array::SizeType result;
15171
15172   arg1 = (Dali::Property::Array *)jarg1;
15173   {
15174     try {
15175       result = (arg1)->Capacity();
15176     } catch (std::out_of_range& e) {
15177       {
15178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15179       };
15180     } catch (std::exception& e) {
15181       {
15182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15183       };
15184     } catch (Dali::DaliException e) {
15185       {
15186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15187       };
15188     } catch (...) {
15189       {
15190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15191       };
15192     }
15193   }
15194
15195   jresult = (unsigned long)result;
15196   return jresult;
15197 }
15198
15199
15200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15201   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15202   Dali::Property::Value *arg2 = 0 ;
15203
15204   arg1 = (Dali::Property::Array *)jarg1;
15205   arg2 = (Dali::Property::Value *)jarg2;
15206   if (!arg2) {
15207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15208     return ;
15209   }
15210   {
15211     try {
15212       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15213     } catch (std::out_of_range& e) {
15214       {
15215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15216       };
15217     } catch (std::exception& e) {
15218       {
15219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15220       };
15221     } catch (Dali::DaliException e) {
15222       {
15223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15224       };
15225     } catch (...) {
15226       {
15227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15228       };
15229     }
15230   }
15231
15232 }
15233
15234
15235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15236   void * jresult ;
15237   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15238   Dali::Property::Value *arg2 = 0 ;
15239   Dali::Property::Array *result = 0 ;
15240
15241   arg1 = (Dali::Property::Array *)jarg1;
15242   arg2 = (Dali::Property::Value *)jarg2;
15243   if (!arg2) {
15244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15245     return 0;
15246   }
15247   {
15248     try {
15249       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15250     } catch (std::out_of_range& e) {
15251       {
15252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15253       };
15254     } catch (std::exception& e) {
15255       {
15256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15257       };
15258     } catch (Dali::DaliException e) {
15259       {
15260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15261       };
15262     } catch (...) {
15263       {
15264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15265       };
15266     }
15267   }
15268
15269   jresult = (void *)result;
15270   return jresult;
15271 }
15272
15273
15274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15275   void * jresult ;
15276   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15277   Dali::Property::Array::SizeType arg2 ;
15278   Dali::Property::Value *result = 0 ;
15279
15280   arg1 = (Dali::Property::Array *)jarg1;
15281   arg2 = (Dali::Property::Array::SizeType)jarg2;
15282   {
15283     try {
15284       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15285     } catch (std::out_of_range& e) {
15286       {
15287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15288       };
15289     } catch (std::exception& e) {
15290       {
15291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15292       };
15293     } catch (Dali::DaliException e) {
15294       {
15295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15296       };
15297     } catch (...) {
15298       {
15299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15300       };
15301     }
15302   }
15303
15304   jresult = (void *)result;
15305   return jresult;
15306 }
15307
15308
15309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15310   void * jresult ;
15311   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15312   Dali::Property::Array::SizeType arg2 ;
15313   Dali::Property::Value *result = 0 ;
15314
15315   arg1 = (Dali::Property::Array *)jarg1;
15316   arg2 = (Dali::Property::Array::SizeType)jarg2;
15317   {
15318     try {
15319       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15320     } catch (std::out_of_range& e) {
15321       {
15322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15323       };
15324     } catch (std::exception& e) {
15325       {
15326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15327       };
15328     } catch (Dali::DaliException e) {
15329       {
15330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15331       };
15332     } catch (...) {
15333       {
15334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15335       };
15336     }
15337   }
15338
15339   jresult = (void *)result;
15340   return jresult;
15341 }
15342
15343
15344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15345   void * jresult ;
15346   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15347   Dali::Property::Array *arg2 = 0 ;
15348   Dali::Property::Array *result = 0 ;
15349
15350   arg1 = (Dali::Property::Array *)jarg1;
15351   arg2 = (Dali::Property::Array *)jarg2;
15352   if (!arg2) {
15353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15354     return 0;
15355   }
15356   {
15357     try {
15358       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15359     } catch (std::out_of_range& e) {
15360       {
15361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15362       };
15363     } catch (std::exception& e) {
15364       {
15365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15366       };
15367     } catch (Dali::DaliException e) {
15368       {
15369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15370       };
15371     } catch (...) {
15372       {
15373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15374       };
15375     }
15376   }
15377
15378   jresult = (void *)result;
15379   return jresult;
15380 }
15381
15382
15383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15384   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15385   enum Dali::Property::Key::Type arg2 ;
15386
15387   arg1 = (Dali::Property::Key *)jarg1;
15388   arg2 = (enum Dali::Property::Key::Type)jarg2;
15389   if (arg1) (arg1)->type = arg2;
15390 }
15391
15392
15393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15394   int jresult ;
15395   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15396   enum Dali::Property::Key::Type result;
15397
15398   arg1 = (Dali::Property::Key *)jarg1;
15399   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15400   jresult = (int)result;
15401   return jresult;
15402 }
15403
15404
15405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15406   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15407   Dali::Property::Index arg2 ;
15408
15409   arg1 = (Dali::Property::Key *)jarg1;
15410   arg2 = (Dali::Property::Index)jarg2;
15411   if (arg1) (arg1)->indexKey = arg2;
15412 }
15413
15414
15415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15416   int jresult ;
15417   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15418   Dali::Property::Index result;
15419
15420   arg1 = (Dali::Property::Key *)jarg1;
15421   result = (Dali::Property::Index) ((arg1)->indexKey);
15422   jresult = result;
15423   return jresult;
15424 }
15425
15426
15427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15428   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15429   std::string *arg2 = 0 ;
15430
15431   arg1 = (Dali::Property::Key *)jarg1;
15432   if (!jarg2) {
15433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15434     return ;
15435   }
15436   std::string arg2_str(jarg2);
15437   arg2 = &arg2_str;
15438   if (arg1) (arg1)->stringKey = *arg2;
15439
15440   //argout typemap for const std::string&
15441
15442 }
15443
15444
15445 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15446   char * jresult ;
15447   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15448   std::string *result = 0 ;
15449
15450   arg1 = (Dali::Property::Key *)jarg1;
15451   result = (std::string *) & ((arg1)->stringKey);
15452   jresult = SWIG_csharp_string_callback(result->c_str());
15453   return jresult;
15454 }
15455
15456
15457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15458   void * jresult ;
15459   std::string *arg1 = 0 ;
15460   Dali::Property::Key *result = 0 ;
15461
15462   if (!jarg1) {
15463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15464     return 0;
15465   }
15466   std::string arg1_str(jarg1);
15467   arg1 = &arg1_str;
15468   {
15469     try {
15470       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15471     } catch (std::out_of_range& e) {
15472       {
15473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15474       };
15475     } catch (std::exception& e) {
15476       {
15477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15478       };
15479     } catch (Dali::DaliException e) {
15480       {
15481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15482       };
15483     } catch (...) {
15484       {
15485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15486       };
15487     }
15488   }
15489
15490   jresult = (void *)result;
15491
15492   //argout typemap for const std::string&
15493
15494   return jresult;
15495 }
15496
15497
15498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15499   void * jresult ;
15500   Dali::Property::Index arg1 ;
15501   Dali::Property::Key *result = 0 ;
15502
15503   arg1 = (Dali::Property::Index)jarg1;
15504   {
15505     try {
15506       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15507     } catch (std::out_of_range& e) {
15508       {
15509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15510       };
15511     } catch (std::exception& e) {
15512       {
15513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15514       };
15515     } catch (Dali::DaliException e) {
15516       {
15517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15518       };
15519     } catch (...) {
15520       {
15521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15522       };
15523     }
15524   }
15525
15526   jresult = (void *)result;
15527   return jresult;
15528 }
15529
15530
15531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15532   unsigned int jresult ;
15533   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15534   std::string *arg2 = 0 ;
15535   bool result;
15536
15537   arg1 = (Dali::Property::Key *)jarg1;
15538   if (!jarg2) {
15539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15540     return 0;
15541   }
15542   std::string arg2_str(jarg2);
15543   arg2 = &arg2_str;
15544   {
15545     try {
15546       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15547     } catch (std::out_of_range& e) {
15548       {
15549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15550       };
15551     } catch (std::exception& e) {
15552       {
15553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15554       };
15555     } catch (Dali::DaliException e) {
15556       {
15557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15558       };
15559     } catch (...) {
15560       {
15561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15562       };
15563     }
15564   }
15565
15566   jresult = result;
15567
15568   //argout typemap for const std::string&
15569
15570   return jresult;
15571 }
15572
15573
15574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15575   unsigned int jresult ;
15576   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15577   Dali::Property::Index arg2 ;
15578   bool result;
15579
15580   arg1 = (Dali::Property::Key *)jarg1;
15581   arg2 = (Dali::Property::Index)jarg2;
15582   {
15583     try {
15584       result = (bool)(arg1)->operator ==(arg2);
15585     } catch (std::out_of_range& e) {
15586       {
15587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15588       };
15589     } catch (std::exception& e) {
15590       {
15591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15592       };
15593     } catch (Dali::DaliException e) {
15594       {
15595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15596       };
15597     } catch (...) {
15598       {
15599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15600       };
15601     }
15602   }
15603
15604   jresult = result;
15605   return jresult;
15606 }
15607
15608
15609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15610   unsigned int jresult ;
15611   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15612   Dali::Property::Key *arg2 = 0 ;
15613   bool result;
15614
15615   arg1 = (Dali::Property::Key *)jarg1;
15616   arg2 = (Dali::Property::Key *)jarg2;
15617   if (!arg2) {
15618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15619     return 0;
15620   }
15621   {
15622     try {
15623       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15624     } catch (std::out_of_range& e) {
15625       {
15626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15627       };
15628     } catch (std::exception& e) {
15629       {
15630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15631       };
15632     } catch (Dali::DaliException e) {
15633       {
15634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15635       };
15636     } catch (...) {
15637       {
15638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15639       };
15640     }
15641   }
15642
15643   jresult = result;
15644   return jresult;
15645 }
15646
15647
15648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15649   unsigned int jresult ;
15650   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15651   std::string *arg2 = 0 ;
15652   bool result;
15653
15654   arg1 = (Dali::Property::Key *)jarg1;
15655   if (!jarg2) {
15656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15657     return 0;
15658   }
15659   std::string arg2_str(jarg2);
15660   arg2 = &arg2_str;
15661   {
15662     try {
15663       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15664     } catch (std::out_of_range& e) {
15665       {
15666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15667       };
15668     } catch (std::exception& e) {
15669       {
15670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15671       };
15672     } catch (Dali::DaliException e) {
15673       {
15674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15675       };
15676     } catch (...) {
15677       {
15678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15679       };
15680     }
15681   }
15682
15683   jresult = result;
15684
15685   //argout typemap for const std::string&
15686
15687   return jresult;
15688 }
15689
15690
15691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15692   unsigned int jresult ;
15693   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15694   Dali::Property::Index arg2 ;
15695   bool result;
15696
15697   arg1 = (Dali::Property::Key *)jarg1;
15698   arg2 = (Dali::Property::Index)jarg2;
15699   {
15700     try {
15701       result = (bool)(arg1)->operator !=(arg2);
15702     } catch (std::out_of_range& e) {
15703       {
15704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15705       };
15706     } catch (std::exception& e) {
15707       {
15708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15709       };
15710     } catch (Dali::DaliException e) {
15711       {
15712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15713       };
15714     } catch (...) {
15715       {
15716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15717       };
15718     }
15719   }
15720
15721   jresult = result;
15722   return jresult;
15723 }
15724
15725
15726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15727   unsigned int jresult ;
15728   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15729   Dali::Property::Key *arg2 = 0 ;
15730   bool result;
15731
15732   arg1 = (Dali::Property::Key *)jarg1;
15733   arg2 = (Dali::Property::Key *)jarg2;
15734   if (!arg2) {
15735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15736     return 0;
15737   }
15738   {
15739     try {
15740       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15741     } catch (std::out_of_range& e) {
15742       {
15743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15744       };
15745     } catch (std::exception& e) {
15746       {
15747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15748       };
15749     } catch (Dali::DaliException e) {
15750       {
15751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15752       };
15753     } catch (...) {
15754       {
15755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15756       };
15757     }
15758   }
15759
15760   jresult = result;
15761   return jresult;
15762 }
15763
15764
15765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15766   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15767
15768   arg1 = (Dali::Property::Key *)jarg1;
15769   {
15770     try {
15771       delete arg1;
15772     } catch (std::out_of_range& e) {
15773       {
15774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15775       };
15776     } catch (std::exception& e) {
15777       {
15778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15779       };
15780     } catch (Dali::DaliException e) {
15781       {
15782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15783       };
15784     } catch (...) {
15785       {
15786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15787       };
15788     }
15789   }
15790
15791 }
15792
15793
15794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15795   void * jresult ;
15796   Dali::Property::Map *result = 0 ;
15797
15798   {
15799     try {
15800       result = (Dali::Property::Map *)new Dali::Property::Map();
15801     } catch (std::out_of_range& e) {
15802       {
15803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15804       };
15805     } catch (std::exception& e) {
15806       {
15807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15808       };
15809     } catch (Dali::DaliException e) {
15810       {
15811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15812       };
15813     } catch (...) {
15814       {
15815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15816       };
15817     }
15818   }
15819
15820   jresult = (void *)result;
15821   return jresult;
15822 }
15823
15824
15825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15826   void * jresult ;
15827   Dali::Property::Map *arg1 = 0 ;
15828   Dali::Property::Map *result = 0 ;
15829
15830   arg1 = (Dali::Property::Map *)jarg1;
15831   if (!arg1) {
15832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15833     return 0;
15834   }
15835   {
15836     try {
15837       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15838     } catch (std::out_of_range& e) {
15839       {
15840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15841       };
15842     } catch (std::exception& e) {
15843       {
15844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15845       };
15846     } catch (Dali::DaliException e) {
15847       {
15848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15849       };
15850     } catch (...) {
15851       {
15852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15853       };
15854     }
15855   }
15856
15857   jresult = (void *)result;
15858   return jresult;
15859 }
15860
15861
15862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15863   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15864
15865   arg1 = (Dali::Property::Map *)jarg1;
15866   {
15867     try {
15868       delete arg1;
15869     } catch (std::out_of_range& e) {
15870       {
15871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15872       };
15873     } catch (std::exception& e) {
15874       {
15875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15876       };
15877     } catch (Dali::DaliException e) {
15878       {
15879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15880       };
15881     } catch (...) {
15882       {
15883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15884       };
15885     }
15886   }
15887
15888 }
15889
15890
15891 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15892   unsigned long jresult ;
15893   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15894   Dali::Property::Map::SizeType result;
15895
15896   arg1 = (Dali::Property::Map *)jarg1;
15897   {
15898     try {
15899       result = ((Dali::Property::Map const *)arg1)->Count();
15900     } catch (std::out_of_range& e) {
15901       {
15902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15903       };
15904     } catch (std::exception& e) {
15905       {
15906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15907       };
15908     } catch (Dali::DaliException e) {
15909       {
15910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15911       };
15912     } catch (...) {
15913       {
15914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15915       };
15916     }
15917   }
15918
15919   jresult = (unsigned long)result;
15920   return jresult;
15921 }
15922
15923
15924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15925   unsigned int jresult ;
15926   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15927   bool result;
15928
15929   arg1 = (Dali::Property::Map *)jarg1;
15930   {
15931     try {
15932       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15933     } catch (std::out_of_range& e) {
15934       {
15935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15936       };
15937     } catch (std::exception& e) {
15938       {
15939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15940       };
15941     } catch (Dali::DaliException e) {
15942       {
15943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15944       };
15945     } catch (...) {
15946       {
15947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15948       };
15949     }
15950   }
15951
15952   jresult = result;
15953   return jresult;
15954 }
15955
15956
15957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15958   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15959   char *arg2 = (char *) 0 ;
15960   Dali::Property::Value *arg3 = 0 ;
15961
15962   arg1 = (Dali::Property::Map *)jarg1;
15963   arg2 = (char *)jarg2;
15964   arg3 = (Dali::Property::Value *)jarg3;
15965   if (!arg3) {
15966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15967     return ;
15968   }
15969   {
15970     try {
15971       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15972     } catch (std::out_of_range& e) {
15973       {
15974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15975       };
15976     } catch (std::exception& e) {
15977       {
15978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15979       };
15980     } catch (Dali::DaliException e) {
15981       {
15982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15983       };
15984     } catch (...) {
15985       {
15986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15987       };
15988     }
15989   }
15990
15991 }
15992
15993
15994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15995   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15996   Dali::Property::Index arg2 ;
15997   Dali::Property::Value *arg3 = 0 ;
15998
15999   arg1 = (Dali::Property::Map *)jarg1;
16000   arg2 = (Dali::Property::Index)jarg2;
16001   arg3 = (Dali::Property::Value *)jarg3;
16002   if (!arg3) {
16003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16004     return ;
16005   }
16006   {
16007     try {
16008       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16009     } catch (std::out_of_range& e) {
16010       {
16011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16012       };
16013     } catch (std::exception& e) {
16014       {
16015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16016       };
16017     } catch (Dali::DaliException e) {
16018       {
16019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16020       };
16021     } catch (...) {
16022       {
16023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16024       };
16025     }
16026   }
16027
16028 }
16029
16030
16031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16032   void * jresult ;
16033   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16034   char *arg2 = (char *) 0 ;
16035   Dali::Property::Value *arg3 = 0 ;
16036   Dali::Property::Map *result = 0 ;
16037
16038   arg1 = (Dali::Property::Map *)jarg1;
16039   arg2 = (char *)jarg2;
16040   arg3 = (Dali::Property::Value *)jarg3;
16041   if (!arg3) {
16042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16043     return 0;
16044   }
16045   {
16046     try {
16047       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16048     } catch (std::out_of_range& e) {
16049       {
16050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16051       };
16052     } catch (std::exception& e) {
16053       {
16054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16055       };
16056     } catch (Dali::DaliException e) {
16057       {
16058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16059       };
16060     } catch (...) {
16061       {
16062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16063       };
16064     }
16065   }
16066
16067   jresult = (void *)result;
16068   return jresult;
16069 }
16070
16071
16072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16073   void * jresult ;
16074   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16075   Dali::Property::Index arg2 ;
16076   Dali::Property::Value *arg3 = 0 ;
16077   Dali::Property::Map *result = 0 ;
16078
16079   arg1 = (Dali::Property::Map *)jarg1;
16080   arg2 = (Dali::Property::Index)jarg2;
16081   arg3 = (Dali::Property::Value *)jarg3;
16082   if (!arg3) {
16083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16084     return 0;
16085   }
16086   {
16087     try {
16088       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16089     } catch (std::out_of_range& e) {
16090       {
16091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16092       };
16093     } catch (std::exception& e) {
16094       {
16095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16096       };
16097     } catch (Dali::DaliException e) {
16098       {
16099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16100       };
16101     } catch (...) {
16102       {
16103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16104       };
16105     }
16106   }
16107
16108   jresult = (void *)result;
16109   return jresult;
16110 }
16111
16112
16113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16114   void * jresult ;
16115   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16116   Dali::Property::Map::SizeType arg2 ;
16117   Dali::Property::Value *result = 0 ;
16118
16119   arg1 = (Dali::Property::Map *)jarg1;
16120   arg2 = (Dali::Property::Map::SizeType)jarg2;
16121   {
16122     try {
16123       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16124     } catch (std::out_of_range& e) {
16125       {
16126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16127       };
16128     } catch (std::exception& e) {
16129       {
16130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16131       };
16132     } catch (Dali::DaliException e) {
16133       {
16134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16135       };
16136     } catch (...) {
16137       {
16138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16139       };
16140     }
16141   }
16142
16143   jresult = (void *)result;
16144   return jresult;
16145 }
16146
16147
16148 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16149   char * jresult ;
16150   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16151   Dali::Property::Map::SizeType arg2 ;
16152   std::string *result = 0 ;
16153
16154   arg1 = (Dali::Property::Map *)jarg1;
16155   arg2 = (Dali::Property::Map::SizeType)jarg2;
16156   {
16157     try {
16158       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16159     } catch (std::out_of_range& e) {
16160       {
16161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16162       };
16163     } catch (std::exception& e) {
16164       {
16165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16166       };
16167     } catch (Dali::DaliException e) {
16168       {
16169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16170       };
16171     } catch (...) {
16172       {
16173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16174       };
16175     }
16176   }
16177
16178   jresult = SWIG_csharp_string_callback(result->c_str());
16179   return jresult;
16180 }
16181
16182
16183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16184   void * jresult ;
16185   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16186   Dali::Property::Map::SizeType arg2 ;
16187   SwigValueWrapper< Dali::Property::Key > result;
16188
16189   arg1 = (Dali::Property::Map *)jarg1;
16190   arg2 = (Dali::Property::Map::SizeType)jarg2;
16191   {
16192     try {
16193       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16194     } catch (std::out_of_range& e) {
16195       {
16196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16197       };
16198     } catch (std::exception& e) {
16199       {
16200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16201       };
16202     } catch (Dali::DaliException e) {
16203       {
16204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16205       };
16206     } catch (...) {
16207       {
16208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16209       };
16210     }
16211   }
16212
16213   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16214   return jresult;
16215 }
16216
16217
16218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16219   void * jresult ;
16220   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16221   Dali::Property::Map::SizeType arg2 ;
16222   StringValuePair *result = 0 ;
16223
16224   arg1 = (Dali::Property::Map *)jarg1;
16225   arg2 = (Dali::Property::Map::SizeType)jarg2;
16226   {
16227     try {
16228       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16229     } catch (std::out_of_range& e) {
16230       {
16231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16232       };
16233     } catch (std::exception& e) {
16234       {
16235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16236       };
16237     } catch (Dali::DaliException e) {
16238       {
16239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16240       };
16241     } catch (...) {
16242       {
16243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16244       };
16245     }
16246   }
16247
16248   jresult = (void *)result;
16249   return jresult;
16250 }
16251
16252
16253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16254   void * jresult ;
16255   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16256   char *arg2 = (char *) 0 ;
16257   Dali::Property::Value *result = 0 ;
16258
16259   arg1 = (Dali::Property::Map *)jarg1;
16260   arg2 = (char *)jarg2;
16261   {
16262     try {
16263       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16264     } catch (std::out_of_range& e) {
16265       {
16266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16267       };
16268     } catch (std::exception& e) {
16269       {
16270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16271       };
16272     } catch (Dali::DaliException e) {
16273       {
16274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16275       };
16276     } catch (...) {
16277       {
16278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16279       };
16280     }
16281   }
16282
16283   jresult = (void *)result;
16284   return jresult;
16285 }
16286
16287
16288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16289   void * jresult ;
16290   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16291   Dali::Property::Index arg2 ;
16292   Dali::Property::Value *result = 0 ;
16293
16294   arg1 = (Dali::Property::Map *)jarg1;
16295   arg2 = (Dali::Property::Index)jarg2;
16296   {
16297     try {
16298       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16299     } catch (std::out_of_range& e) {
16300       {
16301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16302       };
16303     } catch (std::exception& e) {
16304       {
16305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16306       };
16307     } catch (Dali::DaliException e) {
16308       {
16309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16310       };
16311     } catch (...) {
16312       {
16313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16314       };
16315     }
16316   }
16317
16318   jresult = (void *)result;
16319   return jresult;
16320 }
16321
16322
16323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16324   void * jresult ;
16325   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16326   Dali::Property::Index arg2 ;
16327   std::string *arg3 = 0 ;
16328   Dali::Property::Value *result = 0 ;
16329
16330   arg1 = (Dali::Property::Map *)jarg1;
16331   arg2 = (Dali::Property::Index)jarg2;
16332   if (!jarg3) {
16333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16334     return 0;
16335   }
16336   std::string arg3_str(jarg3);
16337   arg3 = &arg3_str;
16338   {
16339     try {
16340       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16341     } catch (std::out_of_range& e) {
16342       {
16343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16344       };
16345     } catch (std::exception& e) {
16346       {
16347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16348       };
16349     } catch (Dali::DaliException e) {
16350       {
16351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16352       };
16353     } catch (...) {
16354       {
16355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16356       };
16357     }
16358   }
16359
16360   jresult = (void *)result;
16361
16362   //argout typemap for const std::string&
16363
16364   return jresult;
16365 }
16366
16367
16368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16369   void * jresult ;
16370   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16371   std::string *arg2 = 0 ;
16372   Dali::Property::Type arg3 ;
16373   Dali::Property::Value *result = 0 ;
16374
16375   arg1 = (Dali::Property::Map *)jarg1;
16376   if (!jarg2) {
16377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16378     return 0;
16379   }
16380   std::string arg2_str(jarg2);
16381   arg2 = &arg2_str;
16382   arg3 = (Dali::Property::Type)jarg3;
16383   {
16384     try {
16385       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16386     } catch (std::out_of_range& e) {
16387       {
16388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16389       };
16390     } catch (std::exception& e) {
16391       {
16392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16393       };
16394     } catch (Dali::DaliException e) {
16395       {
16396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16397       };
16398     } catch (...) {
16399       {
16400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16401       };
16402     }
16403   }
16404
16405   jresult = (void *)result;
16406
16407   //argout typemap for const std::string&
16408
16409   return jresult;
16410 }
16411
16412
16413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16414   void * jresult ;
16415   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16416   Dali::Property::Index arg2 ;
16417   Dali::Property::Type arg3 ;
16418   Dali::Property::Value *result = 0 ;
16419
16420   arg1 = (Dali::Property::Map *)jarg1;
16421   arg2 = (Dali::Property::Index)jarg2;
16422   arg3 = (Dali::Property::Type)jarg3;
16423   {
16424     try {
16425       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16426     } catch (std::out_of_range& e) {
16427       {
16428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16429       };
16430     } catch (std::exception& e) {
16431       {
16432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16433       };
16434     } catch (Dali::DaliException e) {
16435       {
16436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16437       };
16438     } catch (...) {
16439       {
16440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16441       };
16442     }
16443   }
16444
16445   jresult = (void *)result;
16446   return jresult;
16447 }
16448
16449
16450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16451   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16452
16453   arg1 = (Dali::Property::Map *)jarg1;
16454   {
16455     try {
16456       (arg1)->Clear();
16457     } catch (std::out_of_range& e) {
16458       {
16459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16460       };
16461     } catch (std::exception& e) {
16462       {
16463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16464       };
16465     } catch (Dali::DaliException e) {
16466       {
16467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16468       };
16469     } catch (...) {
16470       {
16471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16472       };
16473     }
16474   }
16475
16476 }
16477
16478
16479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16480   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16481   Dali::Property::Map *arg2 = 0 ;
16482
16483   arg1 = (Dali::Property::Map *)jarg1;
16484   arg2 = (Dali::Property::Map *)jarg2;
16485   if (!arg2) {
16486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16487     return ;
16488   }
16489   {
16490     try {
16491       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16492     } catch (std::out_of_range& e) {
16493       {
16494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16495       };
16496     } catch (std::exception& e) {
16497       {
16498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16499       };
16500     } catch (Dali::DaliException e) {
16501       {
16502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16503       };
16504     } catch (...) {
16505       {
16506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16507       };
16508     }
16509   }
16510
16511 }
16512
16513
16514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16515   void * jresult ;
16516   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16517   std::string *arg2 = 0 ;
16518   Dali::Property::Value *result = 0 ;
16519
16520   arg1 = (Dali::Property::Map *)jarg1;
16521   if (!jarg2) {
16522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16523     return 0;
16524   }
16525   std::string arg2_str(jarg2);
16526   arg2 = &arg2_str;
16527   {
16528     try {
16529       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16530     } catch (std::out_of_range& e) {
16531       {
16532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16533       };
16534     } catch (std::exception& e) {
16535       {
16536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16537       };
16538     } catch (Dali::DaliException e) {
16539       {
16540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16541       };
16542     } catch (...) {
16543       {
16544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16545       };
16546     }
16547   }
16548
16549   jresult = (void *)result;
16550
16551   //argout typemap for const std::string&
16552
16553   return jresult;
16554 }
16555
16556
16557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16558   void * jresult ;
16559   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16560   Dali::Property::Index arg2 ;
16561   Dali::Property::Value *result = 0 ;
16562
16563   arg1 = (Dali::Property::Map *)jarg1;
16564   arg2 = (Dali::Property::Index)jarg2;
16565   {
16566     try {
16567       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16568     } catch (std::out_of_range& e) {
16569       {
16570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16571       };
16572     } catch (std::exception& e) {
16573       {
16574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16575       };
16576     } catch (Dali::DaliException e) {
16577       {
16578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16579       };
16580     } catch (...) {
16581       {
16582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16583       };
16584     }
16585   }
16586
16587   jresult = (void *)result;
16588   return jresult;
16589 }
16590
16591
16592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16593   void * jresult ;
16594   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16595   Dali::Property::Map *arg2 = 0 ;
16596   Dali::Property::Map *result = 0 ;
16597
16598   arg1 = (Dali::Property::Map *)jarg1;
16599   arg2 = (Dali::Property::Map *)jarg2;
16600   if (!arg2) {
16601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16602     return 0;
16603   }
16604   {
16605     try {
16606       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16607     } catch (std::out_of_range& e) {
16608       {
16609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16610       };
16611     } catch (std::exception& e) {
16612       {
16613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16614       };
16615     } catch (Dali::DaliException e) {
16616       {
16617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16618       };
16619     } catch (...) {
16620       {
16621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16622       };
16623     }
16624   }
16625
16626   jresult = (void *)result;
16627   return jresult;
16628 }
16629
16630
16631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16632
16633   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16634
16635   if (!jarg2) {
16636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16637     return;
16638   }
16639   std::string arg2_str(jarg2);
16640   std::string* arg2 = &arg2_str;
16641
16642   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16643
16644   {
16645     try {
16646       arg1->operator[]((std::string const &)*arg2) = *arg3;
16647     } catch (std::out_of_range& e) {
16648       {
16649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16650       };
16651     } catch (std::exception& e) {
16652       {
16653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16654       };
16655     } catch (Dali::DaliException e) {
16656       {
16657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16658       };
16659     } catch (...) {
16660       {
16661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16662       };
16663     }
16664   }
16665 }
16666
16667
16668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16669
16670   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16671   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16672   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16673
16674   {
16675     try {
16676       arg1->operator[](arg2) = *arg3;
16677     } catch (std::out_of_range& e) {
16678       {
16679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16680       };
16681     } catch (std::exception& e) {
16682       {
16683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16684       };
16685     } catch (Dali::DaliException e) {
16686       {
16687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16688       };
16689     } catch (...) {
16690       {
16691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16692       };
16693     }
16694   }
16695 }
16696
16697
16698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16699   void * jresult ;
16700   Dali::Property::Value *result = 0 ;
16701
16702   {
16703     try {
16704       result = (Dali::Property::Value *)new Dali::Property::Value();
16705     } catch (std::out_of_range& e) {
16706       {
16707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16708       };
16709     } catch (std::exception& e) {
16710       {
16711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16712       };
16713     } catch (Dali::DaliException e) {
16714       {
16715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16716       };
16717     } catch (...) {
16718       {
16719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16720       };
16721     }
16722   }
16723
16724   jresult = (void *)result;
16725   return jresult;
16726 }
16727
16728
16729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16730   void * jresult ;
16731   bool arg1 ;
16732   Dali::Property::Value *result = 0 ;
16733
16734   arg1 = jarg1 ? true : false;
16735   {
16736     try {
16737       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16738     } catch (std::out_of_range& e) {
16739       {
16740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16741       };
16742     } catch (std::exception& e) {
16743       {
16744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16745       };
16746     } catch (Dali::DaliException e) {
16747       {
16748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16749       };
16750     } catch (...) {
16751       {
16752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16753       };
16754     }
16755   }
16756
16757   jresult = (void *)result;
16758   return jresult;
16759 }
16760
16761
16762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16763   void * jresult ;
16764   int arg1 ;
16765   Dali::Property::Value *result = 0 ;
16766
16767   arg1 = (int)jarg1;
16768   {
16769     try {
16770       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16771     } catch (std::out_of_range& e) {
16772       {
16773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16774       };
16775     } catch (std::exception& e) {
16776       {
16777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16778       };
16779     } catch (Dali::DaliException e) {
16780       {
16781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16782       };
16783     } catch (...) {
16784       {
16785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16786       };
16787     }
16788   }
16789
16790   jresult = (void *)result;
16791   return jresult;
16792 }
16793
16794
16795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16796   void * jresult ;
16797   float arg1 ;
16798   Dali::Property::Value *result = 0 ;
16799
16800   arg1 = (float)jarg1;
16801   {
16802     try {
16803       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16804     } catch (std::out_of_range& e) {
16805       {
16806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16807       };
16808     } catch (std::exception& e) {
16809       {
16810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16811       };
16812     } catch (Dali::DaliException e) {
16813       {
16814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16815       };
16816     } catch (...) {
16817       {
16818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16819       };
16820     }
16821   }
16822
16823   jresult = (void *)result;
16824   return jresult;
16825 }
16826
16827
16828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16829   void * jresult ;
16830   Dali::Vector2 *arg1 = 0 ;
16831   Dali::Property::Value *result = 0 ;
16832
16833   arg1 = (Dali::Vector2 *)jarg1;
16834   if (!arg1) {
16835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16836     return 0;
16837   }
16838   {
16839     try {
16840       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16841     } catch (std::out_of_range& e) {
16842       {
16843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16844       };
16845     } catch (std::exception& e) {
16846       {
16847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16848       };
16849     } catch (Dali::DaliException e) {
16850       {
16851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16852       };
16853     } catch (...) {
16854       {
16855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16856       };
16857     }
16858   }
16859
16860   jresult = (void *)result;
16861   return jresult;
16862 }
16863
16864
16865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16866   void * jresult ;
16867   Dali::Vector3 *arg1 = 0 ;
16868   Dali::Property::Value *result = 0 ;
16869
16870   arg1 = (Dali::Vector3 *)jarg1;
16871   if (!arg1) {
16872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16873     return 0;
16874   }
16875   {
16876     try {
16877       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16878     } catch (std::out_of_range& e) {
16879       {
16880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16881       };
16882     } catch (std::exception& e) {
16883       {
16884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16885       };
16886     } catch (Dali::DaliException e) {
16887       {
16888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16889       };
16890     } catch (...) {
16891       {
16892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16893       };
16894     }
16895   }
16896
16897   jresult = (void *)result;
16898   return jresult;
16899 }
16900
16901
16902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16903   void * jresult ;
16904   Dali::Vector4 *arg1 = 0 ;
16905   Dali::Property::Value *result = 0 ;
16906
16907   arg1 = (Dali::Vector4 *)jarg1;
16908   if (!arg1) {
16909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16910     return 0;
16911   }
16912   {
16913     try {
16914       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16915     } catch (std::out_of_range& e) {
16916       {
16917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16918       };
16919     } catch (std::exception& e) {
16920       {
16921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16922       };
16923     } catch (Dali::DaliException e) {
16924       {
16925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16926       };
16927     } catch (...) {
16928       {
16929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16930       };
16931     }
16932   }
16933
16934   jresult = (void *)result;
16935   return jresult;
16936 }
16937
16938
16939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16940   void * jresult ;
16941   Dali::Matrix3 *arg1 = 0 ;
16942   Dali::Property::Value *result = 0 ;
16943
16944   arg1 = (Dali::Matrix3 *)jarg1;
16945   if (!arg1) {
16946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16947     return 0;
16948   }
16949   {
16950     try {
16951       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16952     } catch (std::out_of_range& e) {
16953       {
16954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16955       };
16956     } catch (std::exception& e) {
16957       {
16958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16959       };
16960     } catch (Dali::DaliException e) {
16961       {
16962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16963       };
16964     } catch (...) {
16965       {
16966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16967       };
16968     }
16969   }
16970
16971   jresult = (void *)result;
16972   return jresult;
16973 }
16974
16975
16976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16977   void * jresult ;
16978   Dali::Matrix *arg1 = 0 ;
16979   Dali::Property::Value *result = 0 ;
16980
16981   arg1 = (Dali::Matrix *)jarg1;
16982   if (!arg1) {
16983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16984     return 0;
16985   }
16986   {
16987     try {
16988       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16989     } catch (std::out_of_range& e) {
16990       {
16991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16992       };
16993     } catch (std::exception& e) {
16994       {
16995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16996       };
16997     } catch (Dali::DaliException e) {
16998       {
16999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17000       };
17001     } catch (...) {
17002       {
17003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17004       };
17005     }
17006   }
17007
17008   jresult = (void *)result;
17009   return jresult;
17010 }
17011
17012
17013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
17014   void * jresult ;
17015   Dali::Rect< int > *arg1 = 0 ;
17016   Dali::Property::Value *result = 0 ;
17017
17018   arg1 = (Dali::Rect< int > *)jarg1;
17019   if (!arg1) {
17020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
17021     return 0;
17022   }
17023   {
17024     try {
17025       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
17026     } catch (std::out_of_range& e) {
17027       {
17028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17029       };
17030     } catch (std::exception& e) {
17031       {
17032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17033       };
17034     } catch (Dali::DaliException e) {
17035       {
17036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17037       };
17038     } catch (...) {
17039       {
17040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17041       };
17042     }
17043   }
17044
17045   jresult = (void *)result;
17046   return jresult;
17047 }
17048
17049
17050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17051   void * jresult ;
17052   Dali::AngleAxis *arg1 = 0 ;
17053   Dali::Property::Value *result = 0 ;
17054
17055   arg1 = (Dali::AngleAxis *)jarg1;
17056   if (!arg1) {
17057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17058     return 0;
17059   }
17060   {
17061     try {
17062       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17063     } catch (std::out_of_range& e) {
17064       {
17065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17066       };
17067     } catch (std::exception& e) {
17068       {
17069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17070       };
17071     } catch (Dali::DaliException e) {
17072       {
17073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17074       };
17075     } catch (...) {
17076       {
17077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17078       };
17079     }
17080   }
17081
17082   jresult = (void *)result;
17083   return jresult;
17084 }
17085
17086
17087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17088   void * jresult ;
17089   Dali::Quaternion *arg1 = 0 ;
17090   Dali::Property::Value *result = 0 ;
17091
17092   arg1 = (Dali::Quaternion *)jarg1;
17093   if (!arg1) {
17094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17095     return 0;
17096   }
17097   {
17098     try {
17099       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17100     } catch (std::out_of_range& e) {
17101       {
17102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17103       };
17104     } catch (std::exception& e) {
17105       {
17106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17107       };
17108     } catch (Dali::DaliException e) {
17109       {
17110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17111       };
17112     } catch (...) {
17113       {
17114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17115       };
17116     }
17117   }
17118
17119   jresult = (void *)result;
17120   return jresult;
17121 }
17122
17123
17124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17125   void * jresult ;
17126   std::string *arg1 = 0 ;
17127   Dali::Property::Value *result = 0 ;
17128
17129   if (!jarg1) {
17130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17131     return 0;
17132   }
17133   std::string arg1_str(jarg1);
17134   arg1 = &arg1_str;
17135   {
17136     try {
17137       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17138     } catch (std::out_of_range& e) {
17139       {
17140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17141       };
17142     } catch (std::exception& e) {
17143       {
17144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17145       };
17146     } catch (Dali::DaliException e) {
17147       {
17148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17149       };
17150     } catch (...) {
17151       {
17152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17153       };
17154     }
17155   }
17156
17157   jresult = (void *)result;
17158
17159   //argout typemap for const std::string&
17160
17161   return jresult;
17162 }
17163
17164
17165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17166   void * jresult ;
17167   Dali::Property::Array *arg1 = 0 ;
17168   Dali::Property::Value *result = 0 ;
17169
17170   arg1 = (Dali::Property::Array *)jarg1;
17171   if (!arg1) {
17172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17173     return 0;
17174   }
17175   {
17176     try {
17177       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17178     } catch (std::out_of_range& e) {
17179       {
17180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17181       };
17182     } catch (std::exception& e) {
17183       {
17184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17185       };
17186     } catch (Dali::DaliException e) {
17187       {
17188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17189       };
17190     } catch (...) {
17191       {
17192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17193       };
17194     }
17195   }
17196
17197   jresult = (void *)result;
17198   return jresult;
17199 }
17200
17201
17202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17203   void * jresult ;
17204   Dali::Property::Map *arg1 = 0 ;
17205   Dali::Property::Value *result = 0 ;
17206
17207   arg1 = (Dali::Property::Map *)jarg1;
17208   if (!arg1) {
17209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17210     return 0;
17211   }
17212   {
17213     try {
17214       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17215     } catch (std::out_of_range& e) {
17216       {
17217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17218       };
17219     } catch (std::exception& e) {
17220       {
17221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17222       };
17223     } catch (Dali::DaliException e) {
17224       {
17225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17226       };
17227     } catch (...) {
17228       {
17229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17230       };
17231     }
17232   }
17233
17234   jresult = (void *)result;
17235   return jresult;
17236 }
17237
17238
17239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17240   void * jresult ;
17241   Extents *arg1 = 0 ;
17242   Dali::Property::Value *result = 0 ;
17243
17244   arg1 = (Extents *)jarg1;
17245   if (!arg1) {
17246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17247     return 0;
17248   }
17249   {
17250     try {
17251       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17252     } catch (std::out_of_range& e) {
17253       {
17254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17255       };
17256     } catch (std::exception& e) {
17257       {
17258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17259       };
17260     } catch (...) {
17261       {
17262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17263       };
17264     }
17265   }
17266   jresult = (void *)result;
17267   return jresult;
17268 }
17269
17270
17271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17272   void * jresult ;
17273   Dali::Property::Type arg1 ;
17274   Dali::Property::Value *result = 0 ;
17275
17276   arg1 = (Dali::Property::Type)jarg1;
17277   {
17278     try {
17279       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17280     } catch (std::out_of_range& e) {
17281       {
17282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17283       };
17284     } catch (std::exception& e) {
17285       {
17286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17287       };
17288     } catch (Dali::DaliException e) {
17289       {
17290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17291       };
17292     } catch (...) {
17293       {
17294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17295       };
17296     }
17297   }
17298
17299   jresult = (void *)result;
17300   return jresult;
17301 }
17302
17303
17304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17305   void * jresult ;
17306   Dali::Property::Value *arg1 = 0 ;
17307   Dali::Property::Value *result = 0 ;
17308
17309   arg1 = (Dali::Property::Value *)jarg1;
17310   if (!arg1) {
17311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17312     return 0;
17313   }
17314   {
17315     try {
17316       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17317     } catch (std::out_of_range& e) {
17318       {
17319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17320       };
17321     } catch (std::exception& e) {
17322       {
17323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17324       };
17325     } catch (Dali::DaliException e) {
17326       {
17327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17328       };
17329     } catch (...) {
17330       {
17331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17332       };
17333     }
17334   }
17335
17336   jresult = (void *)result;
17337   return jresult;
17338 }
17339
17340
17341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17342   void * jresult ;
17343   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17344   Dali::Property::Value *arg2 = 0 ;
17345   Dali::Property::Value *result = 0 ;
17346
17347   arg1 = (Dali::Property::Value *)jarg1;
17348   arg2 = (Dali::Property::Value *)jarg2;
17349   if (!arg2) {
17350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17351     return 0;
17352   }
17353   {
17354     try {
17355       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17356     } catch (std::out_of_range& e) {
17357       {
17358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17359       };
17360     } catch (std::exception& e) {
17361       {
17362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17363       };
17364     } catch (Dali::DaliException e) {
17365       {
17366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17367       };
17368     } catch (...) {
17369       {
17370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17371       };
17372     }
17373   }
17374
17375   jresult = (void *)result;
17376   return jresult;
17377 }
17378
17379
17380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17381   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17382
17383   arg1 = (Dali::Property::Value *)jarg1;
17384   {
17385     try {
17386       delete arg1;
17387     } catch (std::out_of_range& e) {
17388       {
17389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17390       };
17391     } catch (std::exception& e) {
17392       {
17393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17394       };
17395     } catch (Dali::DaliException e) {
17396       {
17397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17398       };
17399     } catch (...) {
17400       {
17401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17402       };
17403     }
17404   }
17405
17406 }
17407
17408
17409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17410   int jresult ;
17411   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17412   Dali::Property::Type result;
17413
17414   arg1 = (Dali::Property::Value *)jarg1;
17415   {
17416     try {
17417       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17418     } catch (std::out_of_range& e) {
17419       {
17420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17421       };
17422     } catch (std::exception& e) {
17423       {
17424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17425       };
17426     } catch (Dali::DaliException e) {
17427       {
17428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17429       };
17430     } catch (...) {
17431       {
17432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17433       };
17434     }
17435   }
17436
17437   jresult = (int)result;
17438   return jresult;
17439 }
17440
17441
17442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17443   unsigned int jresult ;
17444   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17445   bool *arg2 = 0 ;
17446   bool result;
17447
17448   arg1 = (Dali::Property::Value *)jarg1;
17449   arg2 = (bool *)jarg2;
17450   {
17451     try {
17452       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17453     } catch (std::out_of_range& e) {
17454       {
17455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17456       };
17457     } catch (std::exception& e) {
17458       {
17459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17460       };
17461     } catch (Dali::DaliException e) {
17462       {
17463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17464       };
17465     } catch (...) {
17466       {
17467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17468       };
17469     }
17470   }
17471
17472   jresult = result;
17473   return jresult;
17474 }
17475
17476
17477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17478   unsigned int jresult ;
17479   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17480   float *arg2 = 0 ;
17481   bool result;
17482
17483   arg1 = (Dali::Property::Value *)jarg1;
17484   arg2 = (float *)jarg2;
17485   {
17486     try {
17487       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17488     } catch (std::out_of_range& e) {
17489       {
17490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17491       };
17492     } catch (std::exception& e) {
17493       {
17494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17495       };
17496     } catch (Dali::DaliException e) {
17497       {
17498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17499       };
17500     } catch (...) {
17501       {
17502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17503       };
17504     }
17505   }
17506
17507   jresult = result;
17508   return jresult;
17509 }
17510
17511
17512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17513   unsigned int jresult ;
17514   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17515   int *arg2 = 0 ;
17516   bool result;
17517
17518   arg1 = (Dali::Property::Value *)jarg1;
17519   arg2 = (int *)jarg2;
17520   {
17521     try {
17522       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17523     } catch (std::out_of_range& e) {
17524       {
17525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17526       };
17527     } catch (std::exception& e) {
17528       {
17529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17530       };
17531     } catch (Dali::DaliException e) {
17532       {
17533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17534       };
17535     } catch (...) {
17536       {
17537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17538       };
17539     }
17540   }
17541
17542   jresult = result;
17543   return jresult;
17544 }
17545
17546
17547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17548   unsigned int jresult ;
17549   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17550   Dali::Rect< int > *arg2 = 0 ;
17551   bool result;
17552
17553   arg1 = (Dali::Property::Value *)jarg1;
17554   arg2 = (Dali::Rect< int > *)jarg2;
17555   if (!arg2) {
17556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17557     return 0;
17558   }
17559   {
17560     try {
17561       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17562     } catch (std::out_of_range& e) {
17563       {
17564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17565       };
17566     } catch (std::exception& e) {
17567       {
17568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17569       };
17570     } catch (Dali::DaliException e) {
17571       {
17572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17573       };
17574     } catch (...) {
17575       {
17576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17577       };
17578     }
17579   }
17580
17581   jresult = result;
17582   return jresult;
17583 }
17584
17585
17586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17587   unsigned int jresult ;
17588   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17589   Dali::Vector2 *arg2 = 0 ;
17590   bool result;
17591
17592   arg1 = (Dali::Property::Value *)jarg1;
17593   arg2 = (Dali::Vector2 *)jarg2;
17594   if (!arg2) {
17595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17596     return 0;
17597   }
17598   {
17599     try {
17600       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17601     } catch (std::out_of_range& e) {
17602       {
17603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17604       };
17605     } catch (std::exception& e) {
17606       {
17607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17608       };
17609     } catch (Dali::DaliException e) {
17610       {
17611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17612       };
17613     } catch (...) {
17614       {
17615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17616       };
17617     }
17618   }
17619
17620   jresult = result;
17621   return jresult;
17622 }
17623
17624
17625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17626   unsigned int jresult ;
17627   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17628   Dali::Vector3 *arg2 = 0 ;
17629   bool result;
17630
17631   arg1 = (Dali::Property::Value *)jarg1;
17632   arg2 = (Dali::Vector3 *)jarg2;
17633   if (!arg2) {
17634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17635     return 0;
17636   }
17637   {
17638     try {
17639       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17640     } catch (std::out_of_range& e) {
17641       {
17642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17643       };
17644     } catch (std::exception& e) {
17645       {
17646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17647       };
17648     } catch (Dali::DaliException e) {
17649       {
17650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17651       };
17652     } catch (...) {
17653       {
17654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17655       };
17656     }
17657   }
17658
17659   jresult = result;
17660   return jresult;
17661 }
17662
17663
17664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17665   unsigned int jresult ;
17666   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17667   Dali::Vector4 *arg2 = 0 ;
17668   bool result;
17669
17670   arg1 = (Dali::Property::Value *)jarg1;
17671   arg2 = (Dali::Vector4 *)jarg2;
17672   if (!arg2) {
17673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17674     return 0;
17675   }
17676   {
17677     try {
17678       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17679     } catch (std::out_of_range& e) {
17680       {
17681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17682       };
17683     } catch (std::exception& e) {
17684       {
17685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17686       };
17687     } catch (Dali::DaliException e) {
17688       {
17689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17690       };
17691     } catch (...) {
17692       {
17693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17694       };
17695     }
17696   }
17697
17698   jresult = result;
17699   return jresult;
17700 }
17701
17702
17703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17704   unsigned int jresult ;
17705   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17706   Dali::Matrix3 *arg2 = 0 ;
17707   bool result;
17708
17709   arg1 = (Dali::Property::Value *)jarg1;
17710   arg2 = (Dali::Matrix3 *)jarg2;
17711   if (!arg2) {
17712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17713     return 0;
17714   }
17715   {
17716     try {
17717       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17718     } catch (std::out_of_range& e) {
17719       {
17720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17721       };
17722     } catch (std::exception& e) {
17723       {
17724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17725       };
17726     } catch (Dali::DaliException e) {
17727       {
17728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17729       };
17730     } catch (...) {
17731       {
17732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17733       };
17734     }
17735   }
17736
17737   jresult = result;
17738   return jresult;
17739 }
17740
17741
17742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17743   unsigned int jresult ;
17744   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17745   Dali::Matrix *arg2 = 0 ;
17746   bool result;
17747
17748   arg1 = (Dali::Property::Value *)jarg1;
17749   arg2 = (Dali::Matrix *)jarg2;
17750   if (!arg2) {
17751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17752     return 0;
17753   }
17754   {
17755     try {
17756       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17757     } catch (std::out_of_range& e) {
17758       {
17759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17760       };
17761     } catch (std::exception& e) {
17762       {
17763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17764       };
17765     } catch (Dali::DaliException e) {
17766       {
17767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17768       };
17769     } catch (...) {
17770       {
17771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17772       };
17773     }
17774   }
17775
17776   jresult = result;
17777   return jresult;
17778 }
17779
17780
17781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17782   unsigned int jresult ;
17783   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17784   Dali::AngleAxis *arg2 = 0 ;
17785   bool result;
17786
17787   arg1 = (Dali::Property::Value *)jarg1;
17788   arg2 = (Dali::AngleAxis *)jarg2;
17789   if (!arg2) {
17790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17791     return 0;
17792   }
17793   {
17794     try {
17795       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17796     } catch (std::out_of_range& e) {
17797       {
17798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17799       };
17800     } catch (std::exception& e) {
17801       {
17802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17803       };
17804     } catch (Dali::DaliException e) {
17805       {
17806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17807       };
17808     } catch (...) {
17809       {
17810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17811       };
17812     }
17813   }
17814
17815   jresult = result;
17816   return jresult;
17817 }
17818
17819
17820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17821   unsigned int jresult ;
17822   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17823   Dali::Quaternion *arg2 = 0 ;
17824   bool result;
17825
17826   arg1 = (Dali::Property::Value *)jarg1;
17827   arg2 = (Dali::Quaternion *)jarg2;
17828   if (!arg2) {
17829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17830     return 0;
17831   }
17832   {
17833     try {
17834       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17835     } catch (std::out_of_range& e) {
17836       {
17837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17838       };
17839     } catch (std::exception& e) {
17840       {
17841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17842       };
17843     } catch (Dali::DaliException e) {
17844       {
17845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17846       };
17847     } catch (...) {
17848       {
17849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17850       };
17851     }
17852   }
17853
17854   jresult = result;
17855   return jresult;
17856 }
17857
17858
17859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17860   unsigned int jresult ;
17861   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17862   std::string *arg2 = 0 ;
17863   bool result;
17864
17865   arg1 = (Dali::Property::Value *)jarg1;
17866
17867   //typemap in
17868   std::string temp;
17869   arg2 = &temp;
17870
17871   {
17872     try {
17873       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17874     } catch (std::out_of_range& e) {
17875       {
17876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17877       };
17878     } catch (std::exception& e) {
17879       {
17880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17881       };
17882     } catch (Dali::DaliException e) {
17883       {
17884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17885       };
17886     } catch (...) {
17887       {
17888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17889       };
17890     }
17891   }
17892
17893   jresult = result;
17894
17895   //Typemap argout in c++ file.
17896   //This will convert c++ string to c# string
17897   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17898
17899   return jresult;
17900 }
17901
17902
17903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17904   unsigned int jresult ;
17905   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17906   Dali::Property::Array *arg2 = 0 ;
17907   bool result;
17908
17909   arg1 = (Dali::Property::Value *)jarg1;
17910   arg2 = (Dali::Property::Array *)jarg2;
17911   if (!arg2) {
17912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17913     return 0;
17914   }
17915   {
17916     try {
17917       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17918     } catch (std::out_of_range& e) {
17919       {
17920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17921       };
17922     } catch (std::exception& e) {
17923       {
17924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17925       };
17926     } catch (Dali::DaliException e) {
17927       {
17928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17929       };
17930     } catch (...) {
17931       {
17932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17933       };
17934     }
17935   }
17936
17937   jresult = result;
17938   return jresult;
17939 }
17940
17941
17942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17943   unsigned int jresult ;
17944   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17945   Dali::Property::Map *arg2 = 0 ;
17946   bool result;
17947
17948   arg1 = (Dali::Property::Value *)jarg1;
17949   arg2 = (Dali::Property::Map *)jarg2;
17950   if (!arg2) {
17951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17952     return 0;
17953   }
17954   {
17955     try {
17956       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17957     } catch (std::out_of_range& e) {
17958       {
17959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17960       };
17961     } catch (std::exception& e) {
17962       {
17963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17964       };
17965     } catch (Dali::DaliException e) {
17966       {
17967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17968       };
17969     } catch (...) {
17970       {
17971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17972       };
17973     }
17974   }
17975
17976   jresult = result;
17977   return jresult;
17978 }
17979
17980
17981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17982   unsigned int jresult ;
17983   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17984   Extents *arg2 = 0 ;
17985   bool result;
17986
17987   arg1 = (Dali::Property::Value *)jarg1;
17988   arg2 = (Extents *)jarg2;
17989   if (!arg2) {
17990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17991     return 0;
17992   }
17993   {
17994     try {
17995       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17996     } catch (std::out_of_range& e) {
17997       {
17998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17999       };
18000     } catch (std::exception& e) {
18001       {
18002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18003       };
18004     } catch (...) {
18005       {
18006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18007       };
18008     }
18009   }
18010   jresult = result;
18011   return jresult;
18012 }
18013
18014
18015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
18016   void * jresult ;
18017   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18018   Dali::Property::Array *result = 0 ;
18019
18020   arg1 = (Dali::Property::Value *)jarg1;
18021   {
18022     try {
18023       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
18024     } catch (std::out_of_range& e) {
18025       {
18026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18027       };
18028     } catch (std::exception& e) {
18029       {
18030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18031       };
18032     } catch (Dali::DaliException e) {
18033       {
18034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18035       };
18036     } catch (...) {
18037       {
18038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18039       };
18040     }
18041   }
18042
18043   jresult = (void *)result;
18044   return jresult;
18045 }
18046
18047
18048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18049   void * jresult ;
18050   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18051   Dali::Property::Map *result = 0 ;
18052
18053   arg1 = (Dali::Property::Value *)jarg1;
18054   {
18055     try {
18056       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18057     } catch (std::out_of_range& e) {
18058       {
18059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18060       };
18061     } catch (std::exception& e) {
18062       {
18063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18064       };
18065     } catch (Dali::DaliException e) {
18066       {
18067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18068       };
18069     } catch (...) {
18070       {
18071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18072       };
18073     }
18074   }
18075
18076   jresult = (void *)result;
18077   return jresult;
18078 }
18079
18080
18081 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18082   char * jresult ;
18083   Dali::Property::Type arg1 ;
18084   char *result = 0 ;
18085
18086   arg1 = (Dali::Property::Type)jarg1;
18087   {
18088     try {
18089       result = (char *)Dali::PropertyTypes::GetName(arg1);
18090     } catch (std::out_of_range& e) {
18091       {
18092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18093       };
18094     } catch (std::exception& e) {
18095       {
18096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18097       };
18098     } catch (Dali::DaliException e) {
18099       {
18100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18101       };
18102     } catch (...) {
18103       {
18104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18105       };
18106     }
18107   }
18108
18109   jresult = SWIG_csharp_string_callback((const char *)result);
18110   return jresult;
18111 }
18112
18113
18114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18115   unsigned int jresult ;
18116   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18117   std::string *arg2 = 0 ;
18118   Dali::Property::Map *arg3 = 0 ;
18119   bool result;
18120
18121   arg1 = (Dali::BaseObject *)jarg1;
18122   if (!jarg2) {
18123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18124     return 0;
18125   }
18126   std::string arg2_str(jarg2);
18127   arg2 = &arg2_str;
18128   arg3 = (Dali::Property::Map *)jarg3;
18129   if (!arg3) {
18130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18131     return 0;
18132   }
18133   {
18134     try {
18135       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18136     } catch (std::out_of_range& e) {
18137       {
18138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18139       };
18140     } catch (std::exception& e) {
18141       {
18142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18143       };
18144     } catch (Dali::DaliException e) {
18145       {
18146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18147       };
18148     } catch (...) {
18149       {
18150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18151       };
18152     }
18153   }
18154
18155   jresult = result;
18156
18157   //argout typemap for const std::string&
18158
18159   return jresult;
18160 }
18161
18162
18163 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18164   char * jresult ;
18165   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18166   std::string *result = 0 ;
18167
18168   arg1 = (Dali::BaseObject *)jarg1;
18169   {
18170     try {
18171       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18172     } catch (std::out_of_range& e) {
18173       {
18174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18175       };
18176     } catch (std::exception& e) {
18177       {
18178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18179       };
18180     } catch (Dali::DaliException e) {
18181       {
18182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18183       };
18184     } catch (...) {
18185       {
18186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18187       };
18188     }
18189   }
18190
18191   jresult = SWIG_csharp_string_callback(result->c_str());
18192   return jresult;
18193 }
18194
18195
18196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18197   unsigned int jresult ;
18198   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18199   Dali::TypeInfo *arg2 = 0 ;
18200   bool result;
18201
18202   arg1 = (Dali::BaseObject *)jarg1;
18203   arg2 = (Dali::TypeInfo *)jarg2;
18204   if (!arg2) {
18205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18206     return 0;
18207   }
18208   {
18209     try {
18210       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18211     } catch (std::out_of_range& e) {
18212       {
18213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18214       };
18215     } catch (std::exception& e) {
18216       {
18217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18218       };
18219     } catch (Dali::DaliException e) {
18220       {
18221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18222       };
18223     } catch (...) {
18224       {
18225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18226       };
18227     }
18228   }
18229
18230   jresult = result;
18231   return jresult;
18232 }
18233
18234
18235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18236   unsigned int jresult ;
18237   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18238   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18239   std::string *arg3 = 0 ;
18240   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18241   bool result;
18242
18243   arg1 = (Dali::BaseObject *)jarg1;
18244   arg2 = (ConnectionTrackerInterface *)jarg2;
18245   if (!jarg3) {
18246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18247     return 0;
18248   }
18249   std::string arg3_str(jarg3);
18250   arg3 = &arg3_str;
18251   arg4 = (FunctorDelegate *)jarg4;
18252   {
18253     try {
18254       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18255     } catch (std::out_of_range& e) {
18256       {
18257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18258       };
18259     } catch (std::exception& e) {
18260       {
18261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18262       };
18263     } catch (Dali::DaliException e) {
18264       {
18265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18266       };
18267     } catch (...) {
18268       {
18269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18270       };
18271     }
18272   }
18273
18274   jresult = result;
18275
18276   //argout typemap for const std::string&
18277
18278   return jresult;
18279 }
18280
18281
18282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18283   void * jresult ;
18284   Dali::BaseHandle *arg1 = 0 ;
18285   Dali::BaseObject *result = 0 ;
18286
18287   arg1 = (Dali::BaseHandle *)jarg1;
18288   if (!arg1) {
18289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18290     return 0;
18291   }
18292   {
18293     try {
18294       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18295     } catch (std::out_of_range& e) {
18296       {
18297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18298       };
18299     } catch (std::exception& e) {
18300       {
18301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18302       };
18303     } catch (Dali::DaliException e) {
18304       {
18305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18306       };
18307     } catch (...) {
18308       {
18309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18310       };
18311     }
18312   }
18313
18314   jresult = (void *)result;
18315   return jresult;
18316 }
18317
18318
18319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18320   void * jresult ;
18321   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18322   Dali::BaseHandle *result = 0 ;
18323
18324   arg1 = (Dali::BaseObject *)jarg1;
18325   {
18326     try {
18327       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18328     } catch (std::out_of_range& e) {
18329       {
18330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18331       };
18332     } catch (std::exception& e) {
18333       {
18334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18335       };
18336     } catch (Dali::DaliException e) {
18337       {
18338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18339       };
18340     } catch (...) {
18341       {
18342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18343       };
18344     }
18345   }
18346
18347   jresult = (void *)result;
18348   return jresult;
18349 }
18350
18351
18352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18353   void * jresult ;
18354   Dali::BaseHandle *result = 0 ;
18355
18356   {
18357     try {
18358       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18359     } catch (std::out_of_range& e) {
18360       {
18361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18362       };
18363     } catch (std::exception& e) {
18364       {
18365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18366       };
18367     } catch (Dali::DaliException e) {
18368       {
18369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18370       };
18371     } catch (...) {
18372       {
18373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18374       };
18375     }
18376   }
18377
18378   jresult = (void *)result;
18379   return jresult;
18380 }
18381
18382
18383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18384   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18385
18386   arg1 = (Dali::BaseHandle *)jarg1;
18387   {
18388     try {
18389       delete arg1;
18390     } catch (std::out_of_range& e) {
18391       {
18392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18393       };
18394     } catch (std::exception& e) {
18395       {
18396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18397       };
18398     } catch (Dali::DaliException e) {
18399       {
18400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18401       };
18402     } catch (...) {
18403       {
18404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18405       };
18406     }
18407   }
18408
18409 }
18410
18411
18412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18413   void * jresult ;
18414   Dali::BaseHandle *arg1 = 0 ;
18415   Dali::BaseHandle *result = 0 ;
18416
18417   arg1 = (Dali::BaseHandle *)jarg1;
18418   if (!arg1) {
18419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18420     return 0;
18421   }
18422   {
18423     try {
18424       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18425     } catch (std::out_of_range& e) {
18426       {
18427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18428       };
18429     } catch (std::exception& e) {
18430       {
18431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18432       };
18433     } catch (Dali::DaliException e) {
18434       {
18435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18436       };
18437     } catch (...) {
18438       {
18439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18440       };
18441     }
18442   }
18443
18444   jresult = (void *)result;
18445   return jresult;
18446 }
18447
18448
18449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18450   void * jresult ;
18451   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18452   Dali::BaseHandle *arg2 = 0 ;
18453   Dali::BaseHandle *result = 0 ;
18454
18455   arg1 = (Dali::BaseHandle *)jarg1;
18456   arg2 = (Dali::BaseHandle *)jarg2;
18457   if (!arg2) {
18458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18459     return 0;
18460   }
18461   {
18462     try {
18463       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18464     } catch (std::out_of_range& e) {
18465       {
18466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18467       };
18468     } catch (std::exception& e) {
18469       {
18470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18471       };
18472     } catch (Dali::DaliException e) {
18473       {
18474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18475       };
18476     } catch (...) {
18477       {
18478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18479       };
18480     }
18481   }
18482
18483   jresult = (void *)result;
18484   return jresult;
18485 }
18486
18487
18488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18489   unsigned int jresult ;
18490   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18491   std::string *arg2 = 0 ;
18492   Dali::Property::Map *arg3 = 0 ;
18493   bool result;
18494
18495   arg1 = (Dali::BaseHandle *)jarg1;
18496   if (!jarg2) {
18497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18498     return 0;
18499   }
18500   std::string arg2_str(jarg2);
18501   arg2 = &arg2_str;
18502   arg3 = (Dali::Property::Map *)jarg3;
18503   if (!arg3) {
18504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18505     return 0;
18506   }
18507   {
18508     try {
18509       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18510     } catch (std::out_of_range& e) {
18511       {
18512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18513       };
18514     } catch (std::exception& e) {
18515       {
18516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18517       };
18518     } catch (Dali::DaliException e) {
18519       {
18520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18521       };
18522     } catch (...) {
18523       {
18524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18525       };
18526     }
18527   }
18528
18529   jresult = result;
18530
18531   //argout typemap for const std::string&
18532
18533   return jresult;
18534 }
18535
18536
18537 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18538   char * jresult ;
18539   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18540   std::string *result = 0 ;
18541
18542   arg1 = (Dali::BaseHandle *)jarg1;
18543   {
18544     try {
18545       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18546     } catch (std::out_of_range& e) {
18547       {
18548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18549       };
18550     } catch (std::exception& e) {
18551       {
18552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18553       };
18554     } catch (Dali::DaliException e) {
18555       {
18556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18557       };
18558     } catch (...) {
18559       {
18560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18561       };
18562     }
18563   }
18564
18565   jresult = SWIG_csharp_string_callback(result->c_str());
18566   return jresult;
18567 }
18568
18569
18570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18571   unsigned int jresult ;
18572   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18573   Dali::TypeInfo *arg2 = 0 ;
18574   bool result;
18575
18576   arg1 = (Dali::BaseHandle *)jarg1;
18577   arg2 = (Dali::TypeInfo *)jarg2;
18578   if (!arg2) {
18579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18580     return 0;
18581   }
18582   {
18583     try {
18584       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18585     } catch (std::out_of_range& e) {
18586       {
18587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18588       };
18589     } catch (std::exception& e) {
18590       {
18591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18592       };
18593     } catch (Dali::DaliException e) {
18594       {
18595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18596       };
18597     } catch (...) {
18598       {
18599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18600       };
18601     }
18602   }
18603
18604   jresult = result;
18605   return jresult;
18606 }
18607
18608
18609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18610   void * jresult ;
18611   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18612   Dali::BaseObject *result = 0 ;
18613
18614   arg1 = (Dali::BaseHandle *)jarg1;
18615   {
18616     try {
18617       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18618     } catch (std::out_of_range& e) {
18619       {
18620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18621       };
18622     } catch (std::exception& e) {
18623       {
18624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18625       };
18626     } catch (Dali::DaliException e) {
18627       {
18628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18629       };
18630     } catch (...) {
18631       {
18632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18633       };
18634     }
18635   }
18636
18637   jresult = (void *)result;
18638   return jresult;
18639 }
18640
18641
18642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18643   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18644
18645   arg1 = (Dali::BaseHandle *)jarg1;
18646   {
18647     try {
18648       (arg1)->Reset();
18649     } catch (std::out_of_range& e) {
18650       {
18651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18652       };
18653     } catch (std::exception& e) {
18654       {
18655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18656       };
18657     } catch (Dali::DaliException e) {
18658       {
18659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18660       };
18661     } catch (...) {
18662       {
18663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18664       };
18665     }
18666   }
18667
18668 }
18669
18670
18671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18672   unsigned int jresult ;
18673   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18674   Dali::BaseHandle *arg2 = 0 ;
18675   bool result;
18676
18677   arg1 = (Dali::BaseHandle *)jarg1;
18678   arg2 = (Dali::BaseHandle *)jarg2;
18679   if (!arg2) {
18680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18681     return 0;
18682   }
18683   {
18684     try {
18685       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18686     } catch (std::out_of_range& e) {
18687       {
18688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18689       };
18690     } catch (std::exception& e) {
18691       {
18692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18693       };
18694     } catch (Dali::DaliException e) {
18695       {
18696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18697       };
18698     } catch (...) {
18699       {
18700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18701       };
18702     }
18703   }
18704
18705   jresult = result;
18706   return jresult;
18707 }
18708
18709
18710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18711   unsigned int jresult ;
18712   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18713   Dali::BaseHandle *arg2 = 0 ;
18714   bool result;
18715
18716   arg1 = (Dali::BaseHandle *)jarg1;
18717   arg2 = (Dali::BaseHandle *)jarg2;
18718   if (!arg2) {
18719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18720     return 0;
18721   }
18722   {
18723     try {
18724       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18725     } catch (std::out_of_range& e) {
18726       {
18727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18728       };
18729     } catch (std::exception& e) {
18730       {
18731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18732       };
18733     } catch (Dali::DaliException e) {
18734       {
18735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18736       };
18737     } catch (...) {
18738       {
18739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18740       };
18741     }
18742   }
18743
18744   jresult = result;
18745   return jresult;
18746 }
18747
18748
18749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18750   void * jresult ;
18751   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18752   Dali::RefObject *result = 0 ;
18753
18754   arg1 = (Dali::BaseHandle *)jarg1;
18755   {
18756     try {
18757       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18758     } catch (std::out_of_range& e) {
18759       {
18760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18761       };
18762     } catch (std::exception& e) {
18763       {
18764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18765       };
18766     } catch (Dali::DaliException e) {
18767       {
18768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18769       };
18770     } catch (...) {
18771       {
18772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18773       };
18774     }
18775   }
18776
18777   jresult = (void *)result;
18778   return jresult;
18779 }
18780
18781
18782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18783   unsigned int jresult ;
18784   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18785   bool result;
18786
18787   arg1 = (Dali::BaseHandle *)jarg1;
18788   {
18789     try {
18790       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18791     } catch (std::out_of_range& e) {
18792       {
18793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18794       };
18795     } catch (std::exception& e) {
18796       {
18797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18798       };
18799     } catch (Dali::DaliException e) {
18800       {
18801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18802       };
18803     } catch (...) {
18804       {
18805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18806       };
18807     }
18808   }
18809
18810   jresult = result;
18811   return jresult;
18812 }
18813
18814
18815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18816   unsigned int jresult ;
18817   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18818   Dali::BaseHandle *arg2 = 0 ;
18819   bool result;
18820
18821   arg1 = (Dali::BaseHandle *)jarg1;
18822   arg2 = (Dali::BaseHandle *)jarg2;
18823   if (!arg2) {
18824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18825     return 0;
18826   }
18827   {
18828     try {
18829       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18830     } catch (std::out_of_range& e) {
18831       {
18832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18833       };
18834     } catch (std::exception& e) {
18835       {
18836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18837       };
18838     } catch (Dali::DaliException e) {
18839       {
18840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18841       };
18842     } catch (...) {
18843       {
18844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18845       };
18846     }
18847   }
18848
18849   jresult = result;
18850   return jresult;
18851 }
18852
18853
18854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18855   unsigned int jresult ;
18856   Dali::BaseHandle *arg1 = 0 ;
18857   Dali::BaseHandle *arg2 = 0 ;
18858   bool result;
18859
18860   arg1 = (Dali::BaseHandle *)jarg1;
18861   if (!arg1) {
18862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18863     return 0;
18864   }
18865   arg2 = (Dali::BaseHandle *)jarg2;
18866   if (!arg2) {
18867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18868     return 0;
18869   }
18870   {
18871     try {
18872       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18873     } catch (std::out_of_range& e) {
18874       {
18875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18876       };
18877     } catch (std::exception& e) {
18878       {
18879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18880       };
18881     } catch (Dali::DaliException e) {
18882       {
18883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18884       };
18885     } catch (...) {
18886       {
18887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18888       };
18889     }
18890   }
18891
18892   jresult = result;
18893   return jresult;
18894 }
18895
18896
18897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18898   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18899
18900   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18901   {
18902     try {
18903       delete arg1;
18904     } catch (std::out_of_range& e) {
18905       {
18906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18907       };
18908     } catch (std::exception& e) {
18909       {
18910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18911       };
18912     } catch (Dali::DaliException e) {
18913       {
18914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18915       };
18916     } catch (...) {
18917       {
18918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18919       };
18920     }
18921   }
18922
18923 }
18924
18925
18926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18927   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18928   SlotObserver *arg2 = (SlotObserver *) 0 ;
18929   CallbackBase *arg3 = (CallbackBase *) 0 ;
18930
18931   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18932   arg2 = (SlotObserver *)jarg2;
18933   arg3 = (CallbackBase *)jarg3;
18934   {
18935     try {
18936       (arg1)->SignalConnected(arg2,arg3);
18937     } catch (std::out_of_range& e) {
18938       {
18939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18940       };
18941     } catch (std::exception& e) {
18942       {
18943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18944       };
18945     } catch (Dali::DaliException e) {
18946       {
18947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18948       };
18949     } catch (...) {
18950       {
18951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18952       };
18953     }
18954   }
18955
18956 }
18957
18958
18959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18960   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18961
18962   arg1 = (Dali::SignalObserver *)jarg1;
18963   {
18964     try {
18965       delete arg1;
18966     } catch (std::out_of_range& e) {
18967       {
18968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18969       };
18970     } catch (std::exception& e) {
18971       {
18972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18973       };
18974     } catch (Dali::DaliException e) {
18975       {
18976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18977       };
18978     } catch (...) {
18979       {
18980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18981       };
18982     }
18983   }
18984
18985 }
18986
18987
18988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18989   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18990   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18991   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18992
18993   arg1 = (Dali::SignalObserver *)jarg1;
18994   arg2 = (Dali::SlotObserver *)jarg2;
18995   arg3 = (Dali::CallbackBase *)jarg3;
18996   {
18997     try {
18998       (arg1)->SignalDisconnected(arg2,arg3);
18999     } catch (std::out_of_range& e) {
19000       {
19001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19002       };
19003     } catch (std::exception& e) {
19004       {
19005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19006       };
19007     } catch (Dali::DaliException e) {
19008       {
19009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19010       };
19011     } catch (...) {
19012       {
19013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19014       };
19015     }
19016   }
19017
19018 }
19019
19020
19021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
19022   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19023
19024   arg1 = (Dali::SlotObserver *)jarg1;
19025   {
19026     try {
19027       delete arg1;
19028     } catch (std::out_of_range& e) {
19029       {
19030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19031       };
19032     } catch (std::exception& e) {
19033       {
19034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19035       };
19036     } catch (Dali::DaliException e) {
19037       {
19038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19039       };
19040     } catch (...) {
19041       {
19042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19043       };
19044     }
19045   }
19046
19047 }
19048
19049
19050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19051   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19052   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19053
19054   arg1 = (Dali::SlotObserver *)jarg1;
19055   arg2 = (Dali::CallbackBase *)jarg2;
19056   {
19057     try {
19058       (arg1)->SlotDisconnected(arg2);
19059     } catch (std::out_of_range& e) {
19060       {
19061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19062       };
19063     } catch (std::exception& e) {
19064       {
19065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19066       };
19067     } catch (Dali::DaliException e) {
19068       {
19069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19070       };
19071     } catch (...) {
19072       {
19073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19074       };
19075     }
19076   }
19077
19078 }
19079
19080
19081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19082   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19083
19084   arg1 = (Dali::ConnectionTracker *)jarg1;
19085   {
19086     try {
19087       delete arg1;
19088     } catch (std::out_of_range& e) {
19089       {
19090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19091       };
19092     } catch (std::exception& e) {
19093       {
19094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19095       };
19096     } catch (Dali::DaliException e) {
19097       {
19098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19099       };
19100     } catch (...) {
19101       {
19102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19103       };
19104     }
19105   }
19106
19107 }
19108
19109
19110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19111   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19112
19113   arg1 = (Dali::ConnectionTracker *)jarg1;
19114   {
19115     try {
19116       (arg1)->DisconnectAll();
19117     } catch (std::out_of_range& e) {
19118       {
19119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19120       };
19121     } catch (std::exception& e) {
19122       {
19123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19124       };
19125     } catch (Dali::DaliException e) {
19126       {
19127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19128       };
19129     } catch (...) {
19130       {
19131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19132       };
19133     }
19134   }
19135
19136 }
19137
19138
19139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19140   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19141   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19142   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19143
19144   arg1 = (Dali::ConnectionTracker *)jarg1;
19145   arg2 = (Dali::SlotObserver *)jarg2;
19146   arg3 = (Dali::CallbackBase *)jarg3;
19147   {
19148     try {
19149       (arg1)->SignalConnected(arg2,arg3);
19150     } catch (std::out_of_range& e) {
19151       {
19152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19153       };
19154     } catch (std::exception& e) {
19155       {
19156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19157       };
19158     } catch (Dali::DaliException e) {
19159       {
19160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19161       };
19162     } catch (...) {
19163       {
19164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19165       };
19166     }
19167   }
19168
19169 }
19170
19171
19172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19173   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19174   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19175   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19176
19177   arg1 = (Dali::ConnectionTracker *)jarg1;
19178   arg2 = (Dali::SlotObserver *)jarg2;
19179   arg3 = (Dali::CallbackBase *)jarg3;
19180   {
19181     try {
19182       (arg1)->SignalDisconnected(arg2,arg3);
19183     } catch (std::out_of_range& e) {
19184       {
19185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19186       };
19187     } catch (std::exception& e) {
19188       {
19189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19190       };
19191     } catch (Dali::DaliException e) {
19192       {
19193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19194       };
19195     } catch (...) {
19196       {
19197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19198       };
19199     }
19200   }
19201
19202 }
19203
19204
19205 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19206   unsigned long jresult ;
19207   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19208   std::size_t result;
19209
19210   arg1 = (Dali::ConnectionTracker *)jarg1;
19211   {
19212     try {
19213       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19214     } catch (std::out_of_range& e) {
19215       {
19216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19217       };
19218     } catch (std::exception& e) {
19219       {
19220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19221       };
19222     } catch (Dali::DaliException e) {
19223       {
19224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19225       };
19226     } catch (...) {
19227       {
19228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19229       };
19230     }
19231   }
19232
19233   jresult = (unsigned long)result;
19234   return jresult;
19235 }
19236
19237
19238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19239   void * jresult ;
19240   Dali::ObjectRegistry *result = 0 ;
19241
19242   {
19243     try {
19244       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19245     } catch (std::out_of_range& e) {
19246       {
19247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19248       };
19249     } catch (std::exception& e) {
19250       {
19251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19252       };
19253     } catch (Dali::DaliException e) {
19254       {
19255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19256       };
19257     } catch (...) {
19258       {
19259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19260       };
19261     }
19262   }
19263
19264   jresult = (void *)result;
19265   return jresult;
19266 }
19267
19268
19269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19270   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19271
19272   arg1 = (Dali::ObjectRegistry *)jarg1;
19273   {
19274     try {
19275       delete arg1;
19276     } catch (std::out_of_range& e) {
19277       {
19278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19279       };
19280     } catch (std::exception& e) {
19281       {
19282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19283       };
19284     } catch (Dali::DaliException e) {
19285       {
19286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19287       };
19288     } catch (...) {
19289       {
19290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19291       };
19292     }
19293   }
19294
19295 }
19296
19297
19298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19299   void * jresult ;
19300   Dali::ObjectRegistry *arg1 = 0 ;
19301   Dali::ObjectRegistry *result = 0 ;
19302
19303   arg1 = (Dali::ObjectRegistry *)jarg1;
19304   if (!arg1) {
19305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19306     return 0;
19307   }
19308   {
19309     try {
19310       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19311     } catch (std::out_of_range& e) {
19312       {
19313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19314       };
19315     } catch (std::exception& e) {
19316       {
19317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19318       };
19319     } catch (Dali::DaliException e) {
19320       {
19321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19322       };
19323     } catch (...) {
19324       {
19325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19326       };
19327     }
19328   }
19329
19330   jresult = (void *)result;
19331   return jresult;
19332 }
19333
19334
19335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19336   void * jresult ;
19337   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19338   Dali::ObjectRegistry *arg2 = 0 ;
19339   Dali::ObjectRegistry *result = 0 ;
19340
19341   arg1 = (Dali::ObjectRegistry *)jarg1;
19342   arg2 = (Dali::ObjectRegistry *)jarg2;
19343   if (!arg2) {
19344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19345     return 0;
19346   }
19347   {
19348     try {
19349       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19350     } catch (std::out_of_range& e) {
19351       {
19352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19353       };
19354     } catch (std::exception& e) {
19355       {
19356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19357       };
19358     } catch (Dali::DaliException e) {
19359       {
19360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19361       };
19362     } catch (...) {
19363       {
19364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19365       };
19366     }
19367   }
19368
19369   jresult = (void *)result;
19370   return jresult;
19371 }
19372
19373
19374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19375   void * jresult ;
19376   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19377   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19378
19379   arg1 = (Dali::ObjectRegistry *)jarg1;
19380   {
19381     try {
19382       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19383     } catch (std::out_of_range& e) {
19384       {
19385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19386       };
19387     } catch (std::exception& e) {
19388       {
19389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19390       };
19391     } catch (Dali::DaliException e) {
19392       {
19393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19394       };
19395     } catch (...) {
19396       {
19397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19398       };
19399     }
19400   }
19401
19402   jresult = (void *)result;
19403   return jresult;
19404 }
19405
19406
19407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19408   void * jresult ;
19409   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19410   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19411
19412   arg1 = (Dali::ObjectRegistry *)jarg1;
19413   {
19414     try {
19415       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19416     } catch (std::out_of_range& e) {
19417       {
19418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19419       };
19420     } catch (std::exception& e) {
19421       {
19422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19423       };
19424     } catch (Dali::DaliException e) {
19425       {
19426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19427       };
19428     } catch (...) {
19429       {
19430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19431       };
19432     }
19433   }
19434
19435   jresult = (void *)result;
19436   return jresult;
19437 }
19438
19439
19440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19441   void * jresult ;
19442   Dali::PropertyCondition *result = 0 ;
19443
19444   {
19445     try {
19446       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19447     } catch (std::out_of_range& e) {
19448       {
19449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19450       };
19451     } catch (std::exception& e) {
19452       {
19453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19454       };
19455     } catch (Dali::DaliException e) {
19456       {
19457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19458       };
19459     } catch (...) {
19460       {
19461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19462       };
19463     }
19464   }
19465
19466   jresult = (void *)result;
19467   return jresult;
19468 }
19469
19470
19471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19472   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19473
19474   arg1 = (Dali::PropertyCondition *)jarg1;
19475   {
19476     try {
19477       delete arg1;
19478     } catch (std::out_of_range& e) {
19479       {
19480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19481       };
19482     } catch (std::exception& e) {
19483       {
19484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19485       };
19486     } catch (Dali::DaliException e) {
19487       {
19488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19489       };
19490     } catch (...) {
19491       {
19492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19493       };
19494     }
19495   }
19496
19497 }
19498
19499
19500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19501   void * jresult ;
19502   Dali::PropertyCondition *arg1 = 0 ;
19503   Dali::PropertyCondition *result = 0 ;
19504
19505   arg1 = (Dali::PropertyCondition *)jarg1;
19506   if (!arg1) {
19507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19508     return 0;
19509   }
19510   {
19511     try {
19512       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19513     } catch (std::out_of_range& e) {
19514       {
19515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19516       };
19517     } catch (std::exception& e) {
19518       {
19519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19520       };
19521     } catch (Dali::DaliException e) {
19522       {
19523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19524       };
19525     } catch (...) {
19526       {
19527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19528       };
19529     }
19530   }
19531
19532   jresult = (void *)result;
19533   return jresult;
19534 }
19535
19536
19537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19538   void * jresult ;
19539   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19540   Dali::PropertyCondition *arg2 = 0 ;
19541   Dali::PropertyCondition *result = 0 ;
19542
19543   arg1 = (Dali::PropertyCondition *)jarg1;
19544   arg2 = (Dali::PropertyCondition *)jarg2;
19545   if (!arg2) {
19546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19547     return 0;
19548   }
19549   {
19550     try {
19551       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19552     } catch (std::out_of_range& e) {
19553       {
19554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19555       };
19556     } catch (std::exception& e) {
19557       {
19558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19559       };
19560     } catch (Dali::DaliException e) {
19561       {
19562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19563       };
19564     } catch (...) {
19565       {
19566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19567       };
19568     }
19569   }
19570
19571   jresult = (void *)result;
19572   return jresult;
19573 }
19574
19575
19576 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19577   unsigned long jresult ;
19578   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19579   std::size_t result;
19580
19581   arg1 = (Dali::PropertyCondition *)jarg1;
19582   {
19583     try {
19584       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19585     } catch (std::out_of_range& e) {
19586       {
19587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19588       };
19589     } catch (std::exception& e) {
19590       {
19591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19592       };
19593     } catch (...) {
19594       {
19595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19596       };
19597     }
19598   }
19599   jresult = (unsigned long)result;
19600   return jresult;
19601 }
19602
19603
19604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19605   float jresult ;
19606   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19607   std::size_t arg2 ;
19608   float result;
19609
19610   arg1 = (Dali::PropertyCondition *)jarg1;
19611   arg2 = (std::size_t)jarg2;
19612   {
19613     try {
19614       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19615     } catch (std::out_of_range& e) {
19616       {
19617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19618       };
19619     } catch (std::exception& e) {
19620       {
19621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19622       };
19623     } catch (...) {
19624       {
19625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19626       };
19627     }
19628   }
19629   jresult = result;
19630   return jresult;
19631 }
19632
19633
19634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19635   void * jresult ;
19636   float arg1 ;
19637   Dali::PropertyCondition result;
19638
19639   arg1 = (float)jarg1;
19640   {
19641     try {
19642       result = Dali::LessThanCondition(arg1);
19643     } catch (std::out_of_range& e) {
19644       {
19645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19646       };
19647     } catch (std::exception& e) {
19648       {
19649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19650       };
19651     } catch (Dali::DaliException e) {
19652       {
19653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19654       };
19655     } catch (...) {
19656       {
19657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19658       };
19659     }
19660   }
19661
19662   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19663   return jresult;
19664 }
19665
19666
19667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19668   void * jresult ;
19669   float arg1 ;
19670   Dali::PropertyCondition result;
19671
19672   arg1 = (float)jarg1;
19673   {
19674     try {
19675       result = Dali::GreaterThanCondition(arg1);
19676     } catch (std::out_of_range& e) {
19677       {
19678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19679       };
19680     } catch (std::exception& e) {
19681       {
19682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19683       };
19684     } catch (Dali::DaliException e) {
19685       {
19686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19687       };
19688     } catch (...) {
19689       {
19690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19691       };
19692     }
19693   }
19694
19695   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19696   return jresult;
19697 }
19698
19699
19700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19701   void * jresult ;
19702   float arg1 ;
19703   float arg2 ;
19704   Dali::PropertyCondition result;
19705
19706   arg1 = (float)jarg1;
19707   arg2 = (float)jarg2;
19708   {
19709     try {
19710       result = Dali::InsideCondition(arg1,arg2);
19711     } catch (std::out_of_range& e) {
19712       {
19713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19714       };
19715     } catch (std::exception& e) {
19716       {
19717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19718       };
19719     } catch (Dali::DaliException e) {
19720       {
19721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19722       };
19723     } catch (...) {
19724       {
19725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19726       };
19727     }
19728   }
19729
19730   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19731   return jresult;
19732 }
19733
19734
19735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19736   void * jresult ;
19737   float arg1 ;
19738   float arg2 ;
19739   Dali::PropertyCondition result;
19740
19741   arg1 = (float)jarg1;
19742   arg2 = (float)jarg2;
19743   {
19744     try {
19745       result = Dali::OutsideCondition(arg1,arg2);
19746     } catch (std::out_of_range& e) {
19747       {
19748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19749       };
19750     } catch (std::exception& e) {
19751       {
19752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19753       };
19754     } catch (Dali::DaliException e) {
19755       {
19756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19757       };
19758     } catch (...) {
19759       {
19760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19761       };
19762     }
19763   }
19764
19765   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19766   return jresult;
19767 }
19768
19769
19770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19771   void * jresult ;
19772   float arg1 ;
19773   float arg2 ;
19774   Dali::PropertyCondition result;
19775
19776   arg1 = (float)jarg1;
19777   arg2 = (float)jarg2;
19778   {
19779     try {
19780       result = Dali::StepCondition(arg1,arg2);
19781     } catch (std::out_of_range& e) {
19782       {
19783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19784       };
19785     } catch (std::exception& e) {
19786       {
19787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19788       };
19789     } catch (Dali::DaliException e) {
19790       {
19791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19792       };
19793     } catch (...) {
19794       {
19795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19796       };
19797     }
19798   }
19799
19800   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19801   return jresult;
19802 }
19803
19804
19805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19806   void * jresult ;
19807   float arg1 ;
19808   Dali::PropertyCondition result;
19809
19810   arg1 = (float)jarg1;
19811   {
19812     try {
19813       result = Dali::StepCondition(arg1);
19814     } catch (std::out_of_range& e) {
19815       {
19816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19817       };
19818     } catch (std::exception& e) {
19819       {
19820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19821       };
19822     } catch (Dali::DaliException e) {
19823       {
19824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19825       };
19826     } catch (...) {
19827       {
19828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19829       };
19830     }
19831   }
19832
19833   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19834   return jresult;
19835 }
19836
19837
19838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19839   void * jresult ;
19840   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19841   Dali::PropertyCondition result;
19842
19843   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19844   if (!arg1) {
19845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19846     return 0;
19847   }
19848   {
19849     try {
19850       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19851     } catch (std::out_of_range& e) {
19852       {
19853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19854       };
19855     } catch (std::exception& e) {
19856       {
19857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19858       };
19859     } catch (Dali::DaliException e) {
19860       {
19861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19862       };
19863     } catch (...) {
19864       {
19865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19866       };
19867     }
19868   }
19869
19870   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19871   return jresult;
19872 }
19873
19874
19875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19876   void * jresult ;
19877   Dali::PropertyNotification *result = 0 ;
19878
19879   {
19880     try {
19881       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19882     } catch (std::out_of_range& e) {
19883       {
19884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19885       };
19886     } catch (std::exception& e) {
19887       {
19888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19889       };
19890     } catch (Dali::DaliException e) {
19891       {
19892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19893       };
19894     } catch (...) {
19895       {
19896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19897       };
19898     }
19899   }
19900
19901   jresult = (void *)result;
19902   return jresult;
19903 }
19904
19905
19906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19907   void * jresult ;
19908   Dali::BaseHandle arg1 ;
19909   Dali::BaseHandle *argp1 ;
19910   Dali::PropertyNotification result;
19911
19912   argp1 = (Dali::BaseHandle *)jarg1;
19913   if (!argp1) {
19914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19915     return 0;
19916   }
19917   arg1 = *argp1;
19918   {
19919     try {
19920       result = Dali::PropertyNotification::DownCast(arg1);
19921     } catch (std::out_of_range& e) {
19922       {
19923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19924       };
19925     } catch (std::exception& e) {
19926       {
19927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19928       };
19929     } catch (Dali::DaliException e) {
19930       {
19931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19932       };
19933     } catch (...) {
19934       {
19935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19936       };
19937     }
19938   }
19939
19940   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19941   return jresult;
19942 }
19943
19944
19945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19946   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19947
19948   arg1 = (Dali::PropertyNotification *)jarg1;
19949   {
19950     try {
19951       delete arg1;
19952     } catch (std::out_of_range& e) {
19953       {
19954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19955       };
19956     } catch (std::exception& e) {
19957       {
19958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19959       };
19960     } catch (Dali::DaliException e) {
19961       {
19962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19963       };
19964     } catch (...) {
19965       {
19966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19967       };
19968     }
19969   }
19970
19971 }
19972
19973
19974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19975   void * jresult ;
19976   Dali::PropertyNotification *arg1 = 0 ;
19977   Dali::PropertyNotification *result = 0 ;
19978
19979   arg1 = (Dali::PropertyNotification *)jarg1;
19980   if (!arg1) {
19981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19982     return 0;
19983   }
19984   {
19985     try {
19986       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19987     } catch (std::out_of_range& e) {
19988       {
19989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19990       };
19991     } catch (std::exception& e) {
19992       {
19993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19994       };
19995     } catch (Dali::DaliException e) {
19996       {
19997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19998       };
19999     } catch (...) {
20000       {
20001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20002       };
20003     }
20004   }
20005
20006   jresult = (void *)result;
20007   return jresult;
20008 }
20009
20010
20011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
20012   void * jresult ;
20013   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20014   Dali::PropertyNotification *arg2 = 0 ;
20015   Dali::PropertyNotification *result = 0 ;
20016
20017   arg1 = (Dali::PropertyNotification *)jarg1;
20018   arg2 = (Dali::PropertyNotification *)jarg2;
20019   if (!arg2) {
20020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20021     return 0;
20022   }
20023   {
20024     try {
20025       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
20026     } catch (std::out_of_range& e) {
20027       {
20028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20029       };
20030     } catch (std::exception& e) {
20031       {
20032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20033       };
20034     } catch (Dali::DaliException e) {
20035       {
20036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20037       };
20038     } catch (...) {
20039       {
20040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20041       };
20042     }
20043   }
20044
20045   jresult = (void *)result;
20046   return jresult;
20047 }
20048
20049
20050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20051   void * jresult ;
20052   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20053   Dali::PropertyCondition result;
20054
20055   arg1 = (Dali::PropertyNotification *)jarg1;
20056   {
20057     try {
20058       result = (arg1)->GetCondition();
20059     } catch (std::out_of_range& e) {
20060       {
20061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20062       };
20063     } catch (std::exception& e) {
20064       {
20065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20066       };
20067     } catch (Dali::DaliException e) {
20068       {
20069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20070       };
20071     } catch (...) {
20072       {
20073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20074       };
20075     }
20076   }
20077
20078   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20079   return jresult;
20080 }
20081
20082
20083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20084   void * jresult ;
20085   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20086   Dali::Handle result;
20087
20088   arg1 = (Dali::PropertyNotification *)jarg1;
20089   {
20090     try {
20091       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20092     } catch (std::out_of_range& e) {
20093       {
20094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20095       };
20096     } catch (std::exception& e) {
20097       {
20098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20099       };
20100     } catch (Dali::DaliException e) {
20101       {
20102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20103       };
20104     } catch (...) {
20105       {
20106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20107       };
20108     }
20109   }
20110
20111   jresult = new Dali::Handle((const Dali::Handle &)result);
20112   return jresult;
20113 }
20114
20115
20116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20117   int jresult ;
20118   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20119   Dali::Property::Index result;
20120
20121   arg1 = (Dali::PropertyNotification *)jarg1;
20122   {
20123     try {
20124       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20125     } catch (std::out_of_range& e) {
20126       {
20127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20128       };
20129     } catch (std::exception& e) {
20130       {
20131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20132       };
20133     } catch (Dali::DaliException e) {
20134       {
20135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20136       };
20137     } catch (...) {
20138       {
20139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20140       };
20141     }
20142   }
20143
20144   jresult = result;
20145   return jresult;
20146 }
20147
20148
20149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20150   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20151   Dali::PropertyNotification::NotifyMode arg2 ;
20152
20153   arg1 = (Dali::PropertyNotification *)jarg1;
20154   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20155   {
20156     try {
20157       (arg1)->SetNotifyMode(arg2);
20158     } catch (std::out_of_range& e) {
20159       {
20160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20161       };
20162     } catch (std::exception& e) {
20163       {
20164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20165       };
20166     } catch (Dali::DaliException e) {
20167       {
20168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20169       };
20170     } catch (...) {
20171       {
20172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20173       };
20174     }
20175   }
20176
20177 }
20178
20179
20180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20181   int jresult ;
20182   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20183   Dali::PropertyNotification::NotifyMode result;
20184
20185   arg1 = (Dali::PropertyNotification *)jarg1;
20186   {
20187     try {
20188       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20189     } catch (std::out_of_range& e) {
20190       {
20191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20192       };
20193     } catch (std::exception& e) {
20194       {
20195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20196       };
20197     } catch (Dali::DaliException e) {
20198       {
20199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20200       };
20201     } catch (...) {
20202       {
20203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20204       };
20205     }
20206   }
20207
20208   jresult = (int)result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20214   unsigned int jresult ;
20215   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20216   bool result;
20217
20218   arg1 = (Dali::PropertyNotification *)jarg1;
20219   {
20220     try {
20221       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20222     } catch (std::out_of_range& e) {
20223       {
20224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20225       };
20226     } catch (std::exception& e) {
20227       {
20228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20229       };
20230     } catch (Dali::DaliException e) {
20231       {
20232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20233       };
20234     } catch (...) {
20235       {
20236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20237       };
20238     }
20239   }
20240
20241   jresult = result;
20242   return jresult;
20243 }
20244
20245
20246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20247   void * jresult ;
20248   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20249   Dali::PropertyNotifySignalType *result = 0 ;
20250
20251   arg1 = (Dali::PropertyNotification *)jarg1;
20252   {
20253     try {
20254       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20255     } catch (std::out_of_range& e) {
20256       {
20257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20258       };
20259     } catch (std::exception& e) {
20260       {
20261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20262       };
20263     } catch (Dali::DaliException e) {
20264       {
20265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20266       };
20267     } catch (...) {
20268       {
20269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20270       };
20271     }
20272   }
20273
20274   jresult = (void *)result;
20275   return jresult;
20276 }
20277
20278
20279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20280   void * jresult ;
20281   Dali::Handle *result = 0 ;
20282
20283   {
20284     try {
20285       result = (Dali::Handle *)new Dali::Handle();
20286     } catch (std::out_of_range& e) {
20287       {
20288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20289       };
20290     } catch (std::exception& e) {
20291       {
20292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20293       };
20294     } catch (Dali::DaliException e) {
20295       {
20296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20297       };
20298     } catch (...) {
20299       {
20300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20301       };
20302     }
20303   }
20304
20305   jresult = (void *)result;
20306   return jresult;
20307 }
20308
20309
20310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20311   void * jresult ;
20312   Dali::Handle result;
20313
20314   {
20315     try {
20316       result = Dali::Handle::New();
20317     } catch (std::out_of_range& e) {
20318       {
20319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20320       };
20321     } catch (std::exception& e) {
20322       {
20323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20324       };
20325     } catch (Dali::DaliException e) {
20326       {
20327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20328       };
20329     } catch (...) {
20330       {
20331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20332       };
20333     }
20334   }
20335
20336   jresult = new Dali::Handle((const Dali::Handle &)result);
20337   return jresult;
20338 }
20339
20340
20341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20342   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20343
20344   arg1 = (Dali::Handle *)jarg1;
20345   {
20346     try {
20347       delete arg1;
20348     } catch (std::out_of_range& e) {
20349       {
20350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20351       };
20352     } catch (std::exception& e) {
20353       {
20354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20355       };
20356     } catch (Dali::DaliException e) {
20357       {
20358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20359       };
20360     } catch (...) {
20361       {
20362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20363       };
20364     }
20365   }
20366
20367 }
20368
20369
20370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20371   void * jresult ;
20372   Dali::Handle *arg1 = 0 ;
20373   Dali::Handle *result = 0 ;
20374
20375   arg1 = (Dali::Handle *)jarg1;
20376   if (!arg1) {
20377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20378     return 0;
20379   }
20380   {
20381     try {
20382       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20383     } catch (std::out_of_range& e) {
20384       {
20385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20386       };
20387     } catch (std::exception& e) {
20388       {
20389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20390       };
20391     } catch (Dali::DaliException e) {
20392       {
20393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20394       };
20395     } catch (...) {
20396       {
20397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20398       };
20399     }
20400   }
20401
20402   jresult = (void *)result;
20403   return jresult;
20404 }
20405
20406
20407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20408   void * jresult ;
20409   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20410   Dali::Handle *arg2 = 0 ;
20411   Dali::Handle *result = 0 ;
20412
20413   arg1 = (Dali::Handle *)jarg1;
20414   arg2 = (Dali::Handle *)jarg2;
20415   if (!arg2) {
20416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20417     return 0;
20418   }
20419   {
20420     try {
20421       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20422     } catch (std::out_of_range& e) {
20423       {
20424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20425       };
20426     } catch (std::exception& e) {
20427       {
20428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20429       };
20430     } catch (Dali::DaliException e) {
20431       {
20432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20433       };
20434     } catch (...) {
20435       {
20436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20437       };
20438     }
20439   }
20440
20441   jresult = (void *)result;
20442   return jresult;
20443 }
20444
20445
20446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20447   void * jresult ;
20448   Dali::BaseHandle arg1 ;
20449   Dali::BaseHandle *argp1 ;
20450   Dali::Handle result;
20451
20452   argp1 = (Dali::BaseHandle *)jarg1;
20453   if (!argp1) {
20454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20455     return 0;
20456   }
20457   arg1 = *argp1;
20458   {
20459     try {
20460       result = Dali::Handle::DownCast(arg1);
20461     } catch (std::out_of_range& e) {
20462       {
20463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20464       };
20465     } catch (std::exception& e) {
20466       {
20467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20468       };
20469     } catch (Dali::DaliException e) {
20470       {
20471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20472       };
20473     } catch (...) {
20474       {
20475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20476       };
20477     }
20478   }
20479
20480   jresult = new Dali::Handle((const Dali::Handle &)result);
20481   return jresult;
20482 }
20483
20484
20485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20486   unsigned int jresult ;
20487   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20488   Dali::Handle::Capability arg2 ;
20489   bool result;
20490
20491   arg1 = (Dali::Handle *)jarg1;
20492   arg2 = (Dali::Handle::Capability)jarg2;
20493   {
20494     try {
20495       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20496     } catch (std::out_of_range& e) {
20497       {
20498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20499       };
20500     } catch (std::exception& e) {
20501       {
20502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20503       };
20504     } catch (Dali::DaliException e) {
20505       {
20506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20507       };
20508     } catch (...) {
20509       {
20510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20511       };
20512     }
20513   }
20514
20515   jresult = result;
20516   return jresult;
20517 }
20518
20519
20520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20521   unsigned int jresult ;
20522   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20523   unsigned int result;
20524
20525   arg1 = (Dali::Handle *)jarg1;
20526   {
20527     try {
20528       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20529     } catch (std::out_of_range& e) {
20530       {
20531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20532       };
20533     } catch (std::exception& e) {
20534       {
20535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20536       };
20537     } catch (Dali::DaliException e) {
20538       {
20539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20540       };
20541     } catch (...) {
20542       {
20543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20544       };
20545     }
20546   }
20547
20548   jresult = result;
20549   return jresult;
20550 }
20551
20552
20553 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20554   char * jresult ;
20555   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20556   Dali::Property::Index arg2 ;
20557   std::string result;
20558
20559   arg1 = (Dali::Handle *)jarg1;
20560   arg2 = (Dali::Property::Index)jarg2;
20561   {
20562     try {
20563       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20564     } catch (std::out_of_range& e) {
20565       {
20566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20567       };
20568     } catch (std::exception& e) {
20569       {
20570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20571       };
20572     } catch (Dali::DaliException e) {
20573       {
20574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20575       };
20576     } catch (...) {
20577       {
20578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20579       };
20580     }
20581   }
20582
20583   jresult = SWIG_csharp_string_callback((&result)->c_str());
20584   return jresult;
20585 }
20586
20587
20588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20589   int jresult ;
20590   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20591   std::string *arg2 = 0 ;
20592   Dali::Property::Index result;
20593
20594   arg1 = (Dali::Handle *)jarg1;
20595   if (!jarg2) {
20596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20597     return 0;
20598   }
20599   std::string arg2_str(jarg2);
20600   arg2 = &arg2_str;
20601   {
20602     try {
20603       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20604     } catch (std::out_of_range& e) {
20605       {
20606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20607       };
20608     } catch (std::exception& e) {
20609       {
20610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20611       };
20612     } catch (Dali::DaliException e) {
20613       {
20614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20615       };
20616     } catch (...) {
20617       {
20618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20619       };
20620     }
20621   }
20622
20623   jresult = result;
20624
20625   //argout typemap for const std::string&
20626
20627   return jresult;
20628 }
20629
20630
20631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20632   unsigned int jresult ;
20633   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20634   Dali::Property::Index arg2 ;
20635   bool result;
20636
20637   arg1 = (Dali::Handle *)jarg1;
20638   arg2 = (Dali::Property::Index)jarg2;
20639   {
20640     try {
20641       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20642     } catch (std::out_of_range& e) {
20643       {
20644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20645       };
20646     } catch (std::exception& e) {
20647       {
20648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20649       };
20650     } catch (Dali::DaliException e) {
20651       {
20652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20653       };
20654     } catch (...) {
20655       {
20656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20657       };
20658     }
20659   }
20660
20661   jresult = result;
20662   return jresult;
20663 }
20664
20665
20666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20667   unsigned int jresult ;
20668   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20669   Dali::Property::Index arg2 ;
20670   bool result;
20671
20672   arg1 = (Dali::Handle *)jarg1;
20673   arg2 = (Dali::Property::Index)jarg2;
20674   {
20675     try {
20676       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20677     } catch (std::out_of_range& e) {
20678       {
20679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20680       };
20681     } catch (std::exception& e) {
20682       {
20683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20684       };
20685     } catch (Dali::DaliException e) {
20686       {
20687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20688       };
20689     } catch (...) {
20690       {
20691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20692       };
20693     }
20694   }
20695
20696   jresult = result;
20697   return jresult;
20698 }
20699
20700
20701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20702   unsigned int jresult ;
20703   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20704   Dali::Property::Index arg2 ;
20705   bool result;
20706
20707   arg1 = (Dali::Handle *)jarg1;
20708   arg2 = (Dali::Property::Index)jarg2;
20709   {
20710     try {
20711       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20712     } catch (std::out_of_range& e) {
20713       {
20714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20715       };
20716     } catch (std::exception& e) {
20717       {
20718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20719       };
20720     } catch (Dali::DaliException e) {
20721       {
20722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20723       };
20724     } catch (...) {
20725       {
20726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20727       };
20728     }
20729   }
20730
20731   jresult = result;
20732   return jresult;
20733 }
20734
20735
20736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20737   int jresult ;
20738   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20739   Dali::Property::Index arg2 ;
20740   Dali::Property::Type result;
20741
20742   arg1 = (Dali::Handle *)jarg1;
20743   arg2 = (Dali::Property::Index)jarg2;
20744   {
20745     try {
20746       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20747     } catch (std::out_of_range& e) {
20748       {
20749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20750       };
20751     } catch (std::exception& e) {
20752       {
20753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20754       };
20755     } catch (Dali::DaliException e) {
20756       {
20757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20758       };
20759     } catch (...) {
20760       {
20761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20762       };
20763     }
20764   }
20765
20766   jresult = (int)result;
20767   return jresult;
20768 }
20769
20770
20771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20772   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20773   Dali::Property::Index arg2 ;
20774   Dali::Property::Value *arg3 = 0 ;
20775
20776   arg1 = (Dali::Handle *)jarg1;
20777   arg2 = (Dali::Property::Index)jarg2;
20778   arg3 = (Dali::Property::Value *)jarg3;
20779   if (!arg3) {
20780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20781     return ;
20782   }
20783   {
20784     try {
20785       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20786     } catch (std::out_of_range& e) {
20787       {
20788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20789       };
20790     } catch (std::exception& e) {
20791       {
20792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20793       };
20794     } catch (Dali::DaliException e) {
20795       {
20796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20797       };
20798     } catch (...) {
20799       {
20800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20801       };
20802     }
20803   }
20804
20805 }
20806
20807
20808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20809   int jresult ;
20810   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20811   std::string *arg2 = 0 ;
20812   Dali::Property::Value *arg3 = 0 ;
20813   Dali::Property::Index result;
20814
20815   arg1 = (Dali::Handle *)jarg1;
20816   if (!jarg2) {
20817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20818     return 0;
20819   }
20820   std::string arg2_str(jarg2);
20821   arg2 = &arg2_str;
20822   arg3 = (Dali::Property::Value *)jarg3;
20823   if (!arg3) {
20824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20825     return 0;
20826   }
20827   {
20828     try {
20829       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20830     } catch (std::out_of_range& e) {
20831       {
20832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20833       };
20834     } catch (std::exception& e) {
20835       {
20836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20837       };
20838     } catch (Dali::DaliException e) {
20839       {
20840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20841       };
20842     } catch (...) {
20843       {
20844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20845       };
20846     }
20847   }
20848
20849   jresult = result;
20850
20851   //argout typemap for const std::string&
20852
20853   return jresult;
20854 }
20855
20856
20857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20858   int jresult ;
20859   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20860   std::string *arg2 = 0 ;
20861   Dali::Property::Value *arg3 = 0 ;
20862   Dali::Property::AccessMode arg4 ;
20863   Dali::Property::Index result;
20864
20865   arg1 = (Dali::Handle *)jarg1;
20866   if (!jarg2) {
20867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20868     return 0;
20869   }
20870   std::string arg2_str(jarg2);
20871   arg2 = &arg2_str;
20872   arg3 = (Dali::Property::Value *)jarg3;
20873   if (!arg3) {
20874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20875     return 0;
20876   }
20877   arg4 = (Dali::Property::AccessMode)jarg4;
20878   {
20879     try {
20880       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20881     } catch (std::out_of_range& e) {
20882       {
20883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20884       };
20885     } catch (std::exception& e) {
20886       {
20887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20888       };
20889     } catch (Dali::DaliException e) {
20890       {
20891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20892       };
20893     } catch (...) {
20894       {
20895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20896       };
20897     }
20898   }
20899
20900   jresult = result;
20901
20902   //argout typemap for const std::string&
20903
20904   return jresult;
20905 }
20906
20907
20908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20909   void * jresult ;
20910   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20911   Dali::Property::Index arg2 ;
20912   Dali::Property::Value result;
20913
20914   arg1 = (Dali::Handle *)jarg1;
20915   arg2 = (Dali::Property::Index)jarg2;
20916   {
20917     try {
20918       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20919     } catch (std::out_of_range& e) {
20920       {
20921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20922       };
20923     } catch (std::exception& e) {
20924       {
20925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20926       };
20927     } catch (Dali::DaliException e) {
20928       {
20929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20930       };
20931     } catch (...) {
20932       {
20933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20934       };
20935     }
20936   }
20937
20938   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20939   return jresult;
20940 }
20941
20942
20943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20944   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20945   Dali::Property::IndexContainer *arg2 = 0 ;
20946
20947   arg1 = (Dali::Handle *)jarg1;
20948   arg2 = (Dali::Property::IndexContainer *)jarg2;
20949   if (!arg2) {
20950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20951     return ;
20952   }
20953   {
20954     try {
20955       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20956     } catch (std::out_of_range& e) {
20957       {
20958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20959       };
20960     } catch (std::exception& e) {
20961       {
20962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20963       };
20964     } catch (Dali::DaliException e) {
20965       {
20966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20967       };
20968     } catch (...) {
20969       {
20970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20971       };
20972     }
20973   }
20974
20975 }
20976
20977
20978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20979   void * jresult ;
20980   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20981   Dali::Property::Index arg2 ;
20982   Dali::PropertyCondition *arg3 = 0 ;
20983   Dali::PropertyNotification result;
20984
20985   arg1 = (Dali::Handle *)jarg1;
20986   arg2 = (Dali::Property::Index)jarg2;
20987   arg3 = (Dali::PropertyCondition *)jarg3;
20988   if (!arg3) {
20989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20990     return 0;
20991   }
20992   {
20993     try {
20994       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20995     } catch (std::out_of_range& e) {
20996       {
20997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20998       };
20999     } catch (std::exception& e) {
21000       {
21001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21002       };
21003     } catch (Dali::DaliException e) {
21004       {
21005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21006       };
21007     } catch (...) {
21008       {
21009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21010       };
21011     }
21012   }
21013
21014   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21015   return jresult;
21016 }
21017
21018
21019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
21020   void * jresult ;
21021   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21022   Dali::Property::Index arg2 ;
21023   int arg3 ;
21024   Dali::PropertyCondition *arg4 = 0 ;
21025   Dali::PropertyNotification result;
21026
21027   arg1 = (Dali::Handle *)jarg1;
21028   arg2 = (Dali::Property::Index)jarg2;
21029   arg3 = (int)jarg3;
21030   arg4 = (Dali::PropertyCondition *)jarg4;
21031   if (!arg4) {
21032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21033     return 0;
21034   }
21035   {
21036     try {
21037       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21038     } catch (std::out_of_range& e) {
21039       {
21040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21041       };
21042     } catch (std::exception& e) {
21043       {
21044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21045       };
21046     } catch (Dali::DaliException e) {
21047       {
21048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21049       };
21050     } catch (...) {
21051       {
21052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21053       };
21054     }
21055   }
21056
21057   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21058   return jresult;
21059 }
21060
21061
21062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21063   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21064   Dali::PropertyNotification arg2 ;
21065   Dali::PropertyNotification *argp2 ;
21066
21067   arg1 = (Dali::Handle *)jarg1;
21068   argp2 = (Dali::PropertyNotification *)jarg2;
21069   if (!argp2) {
21070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21071     return ;
21072   }
21073   arg2 = *argp2;
21074   {
21075     try {
21076       (arg1)->RemovePropertyNotification(arg2);
21077     } catch (std::out_of_range& e) {
21078       {
21079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21080       };
21081     } catch (std::exception& e) {
21082       {
21083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21084       };
21085     } catch (Dali::DaliException e) {
21086       {
21087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21088       };
21089     } catch (...) {
21090       {
21091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21092       };
21093     }
21094   }
21095
21096 }
21097
21098
21099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21100   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21101
21102   arg1 = (Dali::Handle *)jarg1;
21103   {
21104     try {
21105       (arg1)->RemovePropertyNotifications();
21106     } catch (std::out_of_range& e) {
21107       {
21108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21109       };
21110     } catch (std::exception& e) {
21111       {
21112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21113       };
21114     } catch (Dali::DaliException e) {
21115       {
21116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21117       };
21118     } catch (...) {
21119       {
21120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21121       };
21122     }
21123   }
21124
21125 }
21126
21127
21128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21129   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21130
21131   arg1 = (Dali::Handle *)jarg1;
21132   {
21133     try {
21134       (arg1)->RemoveConstraints();
21135     } catch (std::out_of_range& e) {
21136       {
21137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21138       };
21139     } catch (std::exception& e) {
21140       {
21141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21142       };
21143     } catch (Dali::DaliException e) {
21144       {
21145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21146       };
21147     } catch (...) {
21148       {
21149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21150       };
21151     }
21152   }
21153
21154 }
21155
21156
21157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21158   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21159   unsigned int arg2 ;
21160
21161   arg1 = (Dali::Handle *)jarg1;
21162   arg2 = (unsigned int)jarg2;
21163   {
21164     try {
21165       (arg1)->RemoveConstraints(arg2);
21166     } catch (std::out_of_range& e) {
21167       {
21168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21169       };
21170     } catch (std::exception& e) {
21171       {
21172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21173       };
21174     } catch (Dali::DaliException e) {
21175       {
21176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21177       };
21178     } catch (...) {
21179       {
21180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21181       };
21182     }
21183   }
21184
21185 }
21186
21187
21188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21189   int jresult ;
21190   Dali::Property::Index result;
21191
21192   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21193   jresult = result;
21194   return jresult;
21195 }
21196
21197
21198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21199   void * jresult ;
21200   Dali::Handle result;
21201
21202   {
21203     try {
21204       result = Dali::WeightObject::New();
21205     } catch (std::out_of_range& e) {
21206       {
21207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21208       };
21209     } catch (std::exception& e) {
21210       {
21211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21212       };
21213     } catch (Dali::DaliException e) {
21214       {
21215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21216       };
21217     } catch (...) {
21218       {
21219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21220       };
21221     }
21222   }
21223
21224   jresult = new Dali::Handle((const Dali::Handle &)result);
21225   return jresult;
21226 }
21227
21228
21229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21230   void * jresult ;
21231   Dali::TypeInfo *result = 0 ;
21232
21233   {
21234     try {
21235       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21236     } catch (std::out_of_range& e) {
21237       {
21238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21239       };
21240     } catch (std::exception& e) {
21241       {
21242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21243       };
21244     } catch (Dali::DaliException e) {
21245       {
21246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21247       };
21248     } catch (...) {
21249       {
21250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21251       };
21252     }
21253   }
21254
21255   jresult = (void *)result;
21256   return jresult;
21257 }
21258
21259
21260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21261   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21262
21263   arg1 = (Dali::TypeInfo *)jarg1;
21264   {
21265     try {
21266       delete arg1;
21267     } catch (std::out_of_range& e) {
21268       {
21269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21270       };
21271     } catch (std::exception& e) {
21272       {
21273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21274       };
21275     } catch (Dali::DaliException e) {
21276       {
21277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21278       };
21279     } catch (...) {
21280       {
21281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21282       };
21283     }
21284   }
21285
21286 }
21287
21288
21289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21290   void * jresult ;
21291   Dali::TypeInfo *arg1 = 0 ;
21292   Dali::TypeInfo *result = 0 ;
21293
21294   arg1 = (Dali::TypeInfo *)jarg1;
21295   if (!arg1) {
21296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21297     return 0;
21298   }
21299   {
21300     try {
21301       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21302     } catch (std::out_of_range& e) {
21303       {
21304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21305       };
21306     } catch (std::exception& e) {
21307       {
21308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21309       };
21310     } catch (Dali::DaliException e) {
21311       {
21312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21313       };
21314     } catch (...) {
21315       {
21316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21317       };
21318     }
21319   }
21320
21321   jresult = (void *)result;
21322   return jresult;
21323 }
21324
21325
21326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21327   void * jresult ;
21328   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21329   Dali::TypeInfo *arg2 = 0 ;
21330   Dali::TypeInfo *result = 0 ;
21331
21332   arg1 = (Dali::TypeInfo *)jarg1;
21333   arg2 = (Dali::TypeInfo *)jarg2;
21334   if (!arg2) {
21335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21336     return 0;
21337   }
21338   {
21339     try {
21340       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21341     } catch (std::out_of_range& e) {
21342       {
21343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21344       };
21345     } catch (std::exception& e) {
21346       {
21347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21348       };
21349     } catch (Dali::DaliException e) {
21350       {
21351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21352       };
21353     } catch (...) {
21354       {
21355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21356       };
21357     }
21358   }
21359
21360   jresult = (void *)result;
21361   return jresult;
21362 }
21363
21364
21365 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21366   char * jresult ;
21367   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21368   std::string *result = 0 ;
21369
21370   arg1 = (Dali::TypeInfo *)jarg1;
21371   {
21372     try {
21373       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21374     } catch (std::out_of_range& e) {
21375       {
21376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21377       };
21378     } catch (std::exception& e) {
21379       {
21380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21381       };
21382     } catch (Dali::DaliException e) {
21383       {
21384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21385       };
21386     } catch (...) {
21387       {
21388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21389       };
21390     }
21391   }
21392
21393   jresult = SWIG_csharp_string_callback(result->c_str());
21394   return jresult;
21395 }
21396
21397
21398 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21399   char * jresult ;
21400   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21401   std::string *result = 0 ;
21402
21403   arg1 = (Dali::TypeInfo *)jarg1;
21404   {
21405     try {
21406       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21407     } catch (std::out_of_range& e) {
21408       {
21409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21410       };
21411     } catch (std::exception& e) {
21412       {
21413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21414       };
21415     } catch (Dali::DaliException e) {
21416       {
21417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21418       };
21419     } catch (...) {
21420       {
21421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21422       };
21423     }
21424   }
21425
21426   jresult = SWIG_csharp_string_callback(result->c_str());
21427   return jresult;
21428 }
21429
21430
21431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21432   void * jresult ;
21433   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21434   Dali::BaseHandle result;
21435
21436   arg1 = (Dali::TypeInfo *)jarg1;
21437   {
21438     try {
21439       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21440     } catch (std::out_of_range& e) {
21441       {
21442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21443       };
21444     } catch (std::exception& e) {
21445       {
21446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21447       };
21448     } catch (Dali::DaliException e) {
21449       {
21450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21451       };
21452     } catch (...) {
21453       {
21454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21455       };
21456     }
21457   }
21458
21459   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21460   return jresult;
21461 }
21462
21463
21464 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21465   unsigned long jresult ;
21466   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21467   size_t result;
21468
21469   arg1 = (Dali::TypeInfo *)jarg1;
21470   {
21471     try {
21472       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21473     } catch (std::out_of_range& e) {
21474       {
21475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21476       };
21477     } catch (std::exception& e) {
21478       {
21479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21480       };
21481     } catch (Dali::DaliException e) {
21482       {
21483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21484       };
21485     } catch (...) {
21486       {
21487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21488       };
21489     }
21490   }
21491
21492   jresult = (unsigned long)result;
21493   return jresult;
21494 }
21495
21496
21497 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21498   char * jresult ;
21499   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21500   size_t arg2 ;
21501   std::string result;
21502
21503   arg1 = (Dali::TypeInfo *)jarg1;
21504   arg2 = (size_t)jarg2;
21505   {
21506     try {
21507       result = (arg1)->GetActionName(arg2);
21508     } catch (std::out_of_range& e) {
21509       {
21510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21511       };
21512     } catch (std::exception& e) {
21513       {
21514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21515       };
21516     } catch (Dali::DaliException e) {
21517       {
21518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21519       };
21520     } catch (...) {
21521       {
21522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21523       };
21524     }
21525   }
21526
21527   jresult = SWIG_csharp_string_callback((&result)->c_str());
21528   return jresult;
21529 }
21530
21531
21532 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21533   unsigned long jresult ;
21534   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21535   size_t result;
21536
21537   arg1 = (Dali::TypeInfo *)jarg1;
21538   {
21539     try {
21540       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21541     } catch (std::out_of_range& e) {
21542       {
21543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21544       };
21545     } catch (std::exception& e) {
21546       {
21547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21548       };
21549     } catch (Dali::DaliException e) {
21550       {
21551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21552       };
21553     } catch (...) {
21554       {
21555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21556       };
21557     }
21558   }
21559
21560   jresult = (unsigned long)result;
21561   return jresult;
21562 }
21563
21564
21565 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21566   char * jresult ;
21567   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21568   size_t arg2 ;
21569   std::string result;
21570
21571   arg1 = (Dali::TypeInfo *)jarg1;
21572   arg2 = (size_t)jarg2;
21573   {
21574     try {
21575       result = (arg1)->GetSignalName(arg2);
21576     } catch (std::out_of_range& e) {
21577       {
21578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21579       };
21580     } catch (std::exception& e) {
21581       {
21582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21583       };
21584     } catch (Dali::DaliException e) {
21585       {
21586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21587       };
21588     } catch (...) {
21589       {
21590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21591       };
21592     }
21593   }
21594
21595   jresult = SWIG_csharp_string_callback((&result)->c_str());
21596   return jresult;
21597 }
21598
21599
21600 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21601   unsigned long jresult ;
21602   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21603   size_t result;
21604
21605   arg1 = (Dali::TypeInfo *)jarg1;
21606   {
21607     try {
21608       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21609     } catch (std::out_of_range& e) {
21610       {
21611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21612       };
21613     } catch (std::exception& e) {
21614       {
21615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21616       };
21617     } catch (Dali::DaliException e) {
21618       {
21619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21620       };
21621     } catch (...) {
21622       {
21623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21624       };
21625     }
21626   }
21627
21628   jresult = (unsigned long)result;
21629   return jresult;
21630 }
21631
21632
21633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21634   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21635   Dali::Property::IndexContainer *arg2 = 0 ;
21636
21637   arg1 = (Dali::TypeInfo *)jarg1;
21638   arg2 = (Dali::Property::IndexContainer *)jarg2;
21639   if (!arg2) {
21640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21641     return ;
21642   }
21643   {
21644     try {
21645       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21646     } catch (std::out_of_range& e) {
21647       {
21648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21649       };
21650     } catch (std::exception& e) {
21651       {
21652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21653       };
21654     } catch (Dali::DaliException e) {
21655       {
21656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21657       };
21658     } catch (...) {
21659       {
21660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21661       };
21662     }
21663   }
21664
21665 }
21666
21667
21668 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21669   char * jresult ;
21670   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21671   Dali::Property::Index arg2 ;
21672   std::string *result = 0 ;
21673
21674   arg1 = (Dali::TypeInfo *)jarg1;
21675   arg2 = (Dali::Property::Index)jarg2;
21676   {
21677     try {
21678       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21679     } catch (std::out_of_range& e) {
21680       {
21681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21682       };
21683     } catch (std::exception& e) {
21684       {
21685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21686       };
21687     } catch (Dali::DaliException e) {
21688       {
21689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21690       };
21691     } catch (...) {
21692       {
21693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21694       };
21695     }
21696   }
21697
21698   jresult = SWIG_csharp_string_callback(result->c_str());
21699   return jresult;
21700 }
21701
21702
21703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21704   void * jresult ;
21705   Dali::TypeRegistry result;
21706
21707   {
21708     try {
21709       result = Dali::TypeRegistry::Get();
21710     } catch (std::out_of_range& e) {
21711       {
21712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21713       };
21714     } catch (std::exception& e) {
21715       {
21716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21717       };
21718     } catch (Dali::DaliException e) {
21719       {
21720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21721       };
21722     } catch (...) {
21723       {
21724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21725       };
21726     }
21727   }
21728
21729   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21730   return jresult;
21731 }
21732
21733
21734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21735   void * jresult ;
21736   Dali::TypeRegistry *result = 0 ;
21737
21738   {
21739     try {
21740       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21741     } catch (std::out_of_range& e) {
21742       {
21743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21744       };
21745     } catch (std::exception& e) {
21746       {
21747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21748       };
21749     } catch (Dali::DaliException e) {
21750       {
21751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21752       };
21753     } catch (...) {
21754       {
21755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21756       };
21757     }
21758   }
21759
21760   jresult = (void *)result;
21761   return jresult;
21762 }
21763
21764
21765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21766   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21767
21768   arg1 = (Dali::TypeRegistry *)jarg1;
21769   {
21770     try {
21771       delete arg1;
21772     } catch (std::out_of_range& e) {
21773       {
21774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21775       };
21776     } catch (std::exception& e) {
21777       {
21778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21779       };
21780     } catch (Dali::DaliException e) {
21781       {
21782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21783       };
21784     } catch (...) {
21785       {
21786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21787       };
21788     }
21789   }
21790
21791 }
21792
21793
21794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21795   void * jresult ;
21796   Dali::TypeRegistry *arg1 = 0 ;
21797   Dali::TypeRegistry *result = 0 ;
21798
21799   arg1 = (Dali::TypeRegistry *)jarg1;
21800   if (!arg1) {
21801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21802     return 0;
21803   }
21804   {
21805     try {
21806       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21807     } catch (std::out_of_range& e) {
21808       {
21809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21810       };
21811     } catch (std::exception& e) {
21812       {
21813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21814       };
21815     } catch (Dali::DaliException e) {
21816       {
21817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21818       };
21819     } catch (...) {
21820       {
21821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21822       };
21823     }
21824   }
21825
21826   jresult = (void *)result;
21827   return jresult;
21828 }
21829
21830
21831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21832   void * jresult ;
21833   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21834   Dali::TypeRegistry *arg2 = 0 ;
21835   Dali::TypeRegistry *result = 0 ;
21836
21837   arg1 = (Dali::TypeRegistry *)jarg1;
21838   arg2 = (Dali::TypeRegistry *)jarg2;
21839   if (!arg2) {
21840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21841     return 0;
21842   }
21843   {
21844     try {
21845       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21846     } catch (std::out_of_range& e) {
21847       {
21848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21849       };
21850     } catch (std::exception& e) {
21851       {
21852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21853       };
21854     } catch (Dali::DaliException e) {
21855       {
21856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21857       };
21858     } catch (...) {
21859       {
21860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21861       };
21862     }
21863   }
21864
21865   jresult = (void *)result;
21866   return jresult;
21867 }
21868
21869
21870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21871   void * jresult ;
21872   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21873   std::string *arg2 = 0 ;
21874   Dali::TypeInfo result;
21875
21876   arg1 = (Dali::TypeRegistry *)jarg1;
21877   if (!jarg2) {
21878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21879     return 0;
21880   }
21881   std::string arg2_str(jarg2);
21882   arg2 = &arg2_str;
21883   {
21884     try {
21885       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21886     } catch (std::out_of_range& e) {
21887       {
21888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21889       };
21890     } catch (std::exception& e) {
21891       {
21892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21893       };
21894     } catch (Dali::DaliException e) {
21895       {
21896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21897       };
21898     } catch (...) {
21899       {
21900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21901       };
21902     }
21903   }
21904
21905   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21906
21907   //argout typemap for const std::string&
21908
21909   return jresult;
21910 }
21911
21912
21913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21914   void * jresult ;
21915   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21916   std::type_info *arg2 = 0 ;
21917   Dali::TypeInfo result;
21918
21919   arg1 = (Dali::TypeRegistry *)jarg1;
21920   arg2 = (std::type_info *)jarg2;
21921   if (!arg2) {
21922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21923     return 0;
21924   }
21925   {
21926     try {
21927       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21928     } catch (std::out_of_range& e) {
21929       {
21930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21931       };
21932     } catch (std::exception& e) {
21933       {
21934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21935       };
21936     } catch (Dali::DaliException e) {
21937       {
21938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21939       };
21940     } catch (...) {
21941       {
21942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21943       };
21944     }
21945   }
21946
21947   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21948   return jresult;
21949 }
21950
21951
21952 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21953   unsigned long jresult ;
21954   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21955   size_t result;
21956
21957   arg1 = (Dali::TypeRegistry *)jarg1;
21958   {
21959     try {
21960       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21961     } catch (std::out_of_range& e) {
21962       {
21963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21964       };
21965     } catch (std::exception& e) {
21966       {
21967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21968       };
21969     } catch (Dali::DaliException e) {
21970       {
21971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21972       };
21973     } catch (...) {
21974       {
21975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21976       };
21977     }
21978   }
21979
21980   jresult = (unsigned long)result;
21981   return jresult;
21982 }
21983
21984
21985 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21986   char * jresult ;
21987   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21988   size_t arg2 ;
21989   std::string result;
21990
21991   arg1 = (Dali::TypeRegistry *)jarg1;
21992   arg2 = (size_t)jarg2;
21993   {
21994     try {
21995       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21996     } catch (std::out_of_range& e) {
21997       {
21998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21999       };
22000     } catch (std::exception& e) {
22001       {
22002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22003       };
22004     } catch (Dali::DaliException e) {
22005       {
22006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22007       };
22008     } catch (...) {
22009       {
22010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22011       };
22012     }
22013   }
22014
22015   jresult = SWIG_csharp_string_callback((&result)->c_str());
22016   return jresult;
22017 }
22018
22019
22020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22021   void * jresult ;
22022   std::type_info *arg1 = 0 ;
22023   std::type_info *arg2 = 0 ;
22024   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22025   Dali::TypeRegistration *result = 0 ;
22026
22027   arg1 = (std::type_info *)jarg1;
22028   if (!arg1) {
22029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22030     return 0;
22031   }
22032   arg2 = (std::type_info *)jarg2;
22033   if (!arg2) {
22034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22035     return 0;
22036   }
22037   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22038   {
22039     try {
22040       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22041     } catch (std::out_of_range& e) {
22042       {
22043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22044       };
22045     } catch (std::exception& e) {
22046       {
22047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22048       };
22049     } catch (Dali::DaliException e) {
22050       {
22051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22052       };
22053     } catch (...) {
22054       {
22055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22056       };
22057     }
22058   }
22059
22060   jresult = (void *)result;
22061   return jresult;
22062 }
22063
22064
22065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22066   void * jresult ;
22067   std::type_info *arg1 = 0 ;
22068   std::type_info *arg2 = 0 ;
22069   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22070   bool arg4 ;
22071   Dali::TypeRegistration *result = 0 ;
22072
22073   arg1 = (std::type_info *)jarg1;
22074   if (!arg1) {
22075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22076     return 0;
22077   }
22078   arg2 = (std::type_info *)jarg2;
22079   if (!arg2) {
22080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22081     return 0;
22082   }
22083   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22084   arg4 = jarg4 ? true : false;
22085   {
22086     try {
22087       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22088     } catch (std::out_of_range& e) {
22089       {
22090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22091       };
22092     } catch (std::exception& e) {
22093       {
22094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22095       };
22096     } catch (Dali::DaliException e) {
22097       {
22098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22099       };
22100     } catch (...) {
22101       {
22102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22103       };
22104     }
22105   }
22106
22107   jresult = (void *)result;
22108   return jresult;
22109 }
22110
22111
22112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22113   void * jresult ;
22114   std::string *arg1 = 0 ;
22115   std::type_info *arg2 = 0 ;
22116   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22117   Dali::TypeRegistration *result = 0 ;
22118
22119   if (!jarg1) {
22120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22121     return 0;
22122   }
22123   std::string arg1_str(jarg1);
22124   arg1 = &arg1_str;
22125   arg2 = (std::type_info *)jarg2;
22126   if (!arg2) {
22127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22128     return 0;
22129   }
22130   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22131   {
22132     try {
22133       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22134     } catch (std::out_of_range& e) {
22135       {
22136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22137       };
22138     } catch (std::exception& e) {
22139       {
22140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22141       };
22142     } catch (Dali::DaliException e) {
22143       {
22144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22145       };
22146     } catch (...) {
22147       {
22148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22149       };
22150     }
22151   }
22152
22153   jresult = (void *)result;
22154
22155   //argout typemap for const std::string&
22156
22157   return jresult;
22158 }
22159
22160
22161 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22162   char * jresult ;
22163   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22164   std::string result;
22165
22166   arg1 = (Dali::TypeRegistration *)jarg1;
22167   {
22168     try {
22169       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22170     } catch (std::out_of_range& e) {
22171       {
22172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22173       };
22174     } catch (std::exception& e) {
22175       {
22176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22177       };
22178     } catch (Dali::DaliException e) {
22179       {
22180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22181       };
22182     } catch (...) {
22183       {
22184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22185       };
22186     }
22187   }
22188
22189   jresult = SWIG_csharp_string_callback((&result)->c_str());
22190   return jresult;
22191 }
22192
22193
22194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22195   std::string *arg1 = 0 ;
22196   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22197
22198   if (!jarg1) {
22199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22200     return ;
22201   }
22202   std::string arg1_str(jarg1);
22203   arg1 = &arg1_str;
22204   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22205   {
22206     try {
22207       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22208     } catch (std::out_of_range& e) {
22209       {
22210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22211       };
22212     } catch (std::exception& e) {
22213       {
22214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22215       };
22216     } catch (Dali::DaliException e) {
22217       {
22218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22219       };
22220     } catch (...) {
22221       {
22222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22223       };
22224     }
22225   }
22226
22227
22228   //argout typemap for const std::string&
22229
22230 }
22231
22232
22233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22234   std::string *arg1 = 0 ;
22235   std::string *arg2 = 0 ;
22236   int arg3 ;
22237   Dali::Property::Type arg4 ;
22238   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22239   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22240
22241   if (!jarg1) {
22242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22243     return ;
22244   }
22245   std::string arg1_str(jarg1);
22246   arg1 = &arg1_str;
22247   if (!jarg2) {
22248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22249     return ;
22250   }
22251   std::string arg2_str(jarg2);
22252   arg2 = &arg2_str;
22253   arg3 = (int)jarg3;
22254   arg4 = (Dali::Property::Type)jarg4;
22255   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22256   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22257   {
22258     try {
22259       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22260     } catch (std::out_of_range& e) {
22261       {
22262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22263       };
22264     } catch (std::exception& e) {
22265       {
22266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22267       };
22268     } catch (Dali::DaliException e) {
22269       {
22270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22271       };
22272     } catch (...) {
22273       {
22274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22275       };
22276     }
22277   }
22278
22279
22280   //argout typemap for const std::string&
22281
22282
22283   //argout typemap for const std::string&
22284
22285 }
22286
22287
22288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22289   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22290
22291   arg1 = (Dali::TypeRegistration *)jarg1;
22292   {
22293     try {
22294       delete arg1;
22295     } catch (std::out_of_range& e) {
22296       {
22297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22298       };
22299     } catch (std::exception& e) {
22300       {
22301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22302       };
22303     } catch (Dali::DaliException e) {
22304       {
22305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22306       };
22307     } catch (...) {
22308       {
22309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22310       };
22311     }
22312   }
22313
22314 }
22315
22316
22317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22318   void * jresult ;
22319   Dali::TypeRegistration *arg1 = 0 ;
22320   std::string *arg2 = 0 ;
22321   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22322   Dali::SignalConnectorType *result = 0 ;
22323
22324   arg1 = (Dali::TypeRegistration *)jarg1;
22325   if (!arg1) {
22326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22327     return 0;
22328   }
22329   if (!jarg2) {
22330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22331     return 0;
22332   }
22333   std::string arg2_str(jarg2);
22334   arg2 = &arg2_str;
22335   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22336   {
22337     try {
22338       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22339     } catch (std::out_of_range& e) {
22340       {
22341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22342       };
22343     } catch (std::exception& e) {
22344       {
22345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22346       };
22347     } catch (Dali::DaliException e) {
22348       {
22349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22350       };
22351     } catch (...) {
22352       {
22353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22354       };
22355     }
22356   }
22357
22358   jresult = (void *)result;
22359
22360   //argout typemap for const std::string&
22361
22362   return jresult;
22363 }
22364
22365
22366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22367   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22368
22369   arg1 = (Dali::SignalConnectorType *)jarg1;
22370   {
22371     try {
22372       delete arg1;
22373     } catch (std::out_of_range& e) {
22374       {
22375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22376       };
22377     } catch (std::exception& e) {
22378       {
22379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22380       };
22381     } catch (Dali::DaliException e) {
22382       {
22383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22384       };
22385     } catch (...) {
22386       {
22387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22388       };
22389     }
22390   }
22391
22392 }
22393
22394
22395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22396   void * jresult ;
22397   Dali::TypeRegistration *arg1 = 0 ;
22398   std::string *arg2 = 0 ;
22399   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22400   Dali::TypeAction *result = 0 ;
22401
22402   arg1 = (Dali::TypeRegistration *)jarg1;
22403   if (!arg1) {
22404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22405     return 0;
22406   }
22407   if (!jarg2) {
22408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22409     return 0;
22410   }
22411   std::string arg2_str(jarg2);
22412   arg2 = &arg2_str;
22413   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22414   {
22415     try {
22416       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22417     } catch (std::out_of_range& e) {
22418       {
22419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22420       };
22421     } catch (std::exception& e) {
22422       {
22423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22424       };
22425     } catch (Dali::DaliException e) {
22426       {
22427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22428       };
22429     } catch (...) {
22430       {
22431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22432       };
22433     }
22434   }
22435
22436   jresult = (void *)result;
22437
22438   //argout typemap for const std::string&
22439
22440   return jresult;
22441 }
22442
22443
22444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22445   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22446
22447   arg1 = (Dali::TypeAction *)jarg1;
22448   {
22449     try {
22450       delete arg1;
22451     } catch (std::out_of_range& e) {
22452       {
22453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22454       };
22455     } catch (std::exception& e) {
22456       {
22457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22458       };
22459     } catch (Dali::DaliException e) {
22460       {
22461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22462       };
22463     } catch (...) {
22464       {
22465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22466       };
22467     }
22468   }
22469
22470 }
22471
22472
22473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22474   void * jresult ;
22475   Dali::TypeRegistration *arg1 = 0 ;
22476   std::string *arg2 = 0 ;
22477   Dali::Property::Index arg3 ;
22478   Dali::Property::Type arg4 ;
22479   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22480   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22481   Dali::PropertyRegistration *result = 0 ;
22482
22483   arg1 = (Dali::TypeRegistration *)jarg1;
22484   if (!arg1) {
22485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22486     return 0;
22487   }
22488   if (!jarg2) {
22489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22490     return 0;
22491   }
22492   std::string arg2_str(jarg2);
22493   arg2 = &arg2_str;
22494   arg3 = (Dali::Property::Index)jarg3;
22495   arg4 = (Dali::Property::Type)jarg4;
22496   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22497   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22498   {
22499     try {
22500       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22501     } catch (std::out_of_range& e) {
22502       {
22503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22504       };
22505     } catch (std::exception& e) {
22506       {
22507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22508       };
22509     } catch (Dali::DaliException e) {
22510       {
22511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22512       };
22513     } catch (...) {
22514       {
22515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22516       };
22517     }
22518   }
22519
22520   jresult = (void *)result;
22521
22522   //argout typemap for const std::string&
22523
22524   return jresult;
22525 }
22526
22527
22528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22529   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22530
22531   arg1 = (Dali::PropertyRegistration *)jarg1;
22532   {
22533     try {
22534       delete arg1;
22535     } catch (std::out_of_range& e) {
22536       {
22537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22538       };
22539     } catch (std::exception& e) {
22540       {
22541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22542       };
22543     } catch (Dali::DaliException e) {
22544       {
22545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22546       };
22547     } catch (...) {
22548       {
22549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22550       };
22551     }
22552   }
22553
22554 }
22555
22556
22557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22558   void * jresult ;
22559   Dali::TypeRegistration *arg1 = 0 ;
22560   std::string *arg2 = 0 ;
22561   Dali::Property::Index arg3 ;
22562   Dali::Property::Type arg4 ;
22563   Dali::AnimatablePropertyRegistration *result = 0 ;
22564
22565   arg1 = (Dali::TypeRegistration *)jarg1;
22566   if (!arg1) {
22567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22568     return 0;
22569   }
22570   if (!jarg2) {
22571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22572     return 0;
22573   }
22574   std::string arg2_str(jarg2);
22575   arg2 = &arg2_str;
22576   arg3 = (Dali::Property::Index)jarg3;
22577   arg4 = (Dali::Property::Type)jarg4;
22578   {
22579     try {
22580       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22581     } catch (std::out_of_range& e) {
22582       {
22583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22584       };
22585     } catch (std::exception& e) {
22586       {
22587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22588       };
22589     } catch (Dali::DaliException e) {
22590       {
22591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22592       };
22593     } catch (...) {
22594       {
22595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22596       };
22597     }
22598   }
22599
22600   jresult = (void *)result;
22601
22602   //argout typemap for const std::string&
22603
22604   return jresult;
22605 }
22606
22607
22608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22609   void * jresult ;
22610   Dali::TypeRegistration *arg1 = 0 ;
22611   std::string *arg2 = 0 ;
22612   Dali::Property::Index arg3 ;
22613   Dali::Property::Value *arg4 = 0 ;
22614   Dali::AnimatablePropertyRegistration *result = 0 ;
22615
22616   arg1 = (Dali::TypeRegistration *)jarg1;
22617   if (!arg1) {
22618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22619     return 0;
22620   }
22621   if (!jarg2) {
22622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22623     return 0;
22624   }
22625   std::string arg2_str(jarg2);
22626   arg2 = &arg2_str;
22627   arg3 = (Dali::Property::Index)jarg3;
22628   arg4 = (Dali::Property::Value *)jarg4;
22629   if (!arg4) {
22630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22631     return 0;
22632   }
22633   {
22634     try {
22635       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22636     } catch (std::out_of_range& e) {
22637       {
22638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22639       };
22640     } catch (std::exception& e) {
22641       {
22642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22643       };
22644     } catch (Dali::DaliException e) {
22645       {
22646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22647       };
22648     } catch (...) {
22649       {
22650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22651       };
22652     }
22653   }
22654
22655   jresult = (void *)result;
22656
22657   //argout typemap for const std::string&
22658
22659   return jresult;
22660 }
22661
22662
22663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22664   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22665
22666   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22667   {
22668     try {
22669       delete arg1;
22670     } catch (std::out_of_range& e) {
22671       {
22672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22673       };
22674     } catch (std::exception& e) {
22675       {
22676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22677       };
22678     } catch (Dali::DaliException e) {
22679       {
22680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22681       };
22682     } catch (...) {
22683       {
22684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22685       };
22686     }
22687   }
22688
22689 }
22690
22691
22692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22693   void * jresult ;
22694   Dali::TypeRegistration *arg1 = 0 ;
22695   std::string *arg2 = 0 ;
22696   Dali::Property::Index arg3 ;
22697   Dali::Property::Index arg4 ;
22698   unsigned int arg5 ;
22699   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22700
22701   arg1 = (Dali::TypeRegistration *)jarg1;
22702   if (!arg1) {
22703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22704     return 0;
22705   }
22706   if (!jarg2) {
22707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22708     return 0;
22709   }
22710   std::string arg2_str(jarg2);
22711   arg2 = &arg2_str;
22712   arg3 = (Dali::Property::Index)jarg3;
22713   arg4 = (Dali::Property::Index)jarg4;
22714   arg5 = (unsigned int)jarg5;
22715   {
22716     try {
22717       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22718     } catch (std::out_of_range& e) {
22719       {
22720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22721       };
22722     } catch (std::exception& e) {
22723       {
22724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22725       };
22726     } catch (Dali::DaliException e) {
22727       {
22728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22729       };
22730     } catch (...) {
22731       {
22732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22733       };
22734     }
22735   }
22736
22737   jresult = (void *)result;
22738
22739   //argout typemap for const std::string&
22740
22741   return jresult;
22742 }
22743
22744
22745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22746   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22747
22748   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22749   {
22750     try {
22751       delete arg1;
22752     } catch (std::out_of_range& e) {
22753       {
22754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22755       };
22756     } catch (std::exception& e) {
22757       {
22758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22759       };
22760     } catch (Dali::DaliException e) {
22761       {
22762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22763       };
22764     } catch (...) {
22765       {
22766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22767       };
22768     }
22769   }
22770
22771 }
22772
22773
22774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22775   void * jresult ;
22776   Dali::TypeRegistration *arg1 = 0 ;
22777   std::string *arg2 = 0 ;
22778   Dali::Property::Index arg3 ;
22779   Dali::Property::Type arg4 ;
22780   Dali::ChildPropertyRegistration *result = 0 ;
22781
22782   arg1 = (Dali::TypeRegistration *)jarg1;
22783   if (!arg1) {
22784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22785     return 0;
22786   }
22787   if (!jarg2) {
22788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22789     return 0;
22790   }
22791   std::string arg2_str(jarg2);
22792   arg2 = &arg2_str;
22793   arg3 = (Dali::Property::Index)jarg3;
22794   arg4 = (Dali::Property::Type)jarg4;
22795   {
22796     try {
22797       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22798     } catch (std::out_of_range& e) {
22799       {
22800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22801       };
22802     } catch (std::exception& e) {
22803       {
22804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22805       };
22806     } catch (Dali::DaliException e) {
22807       {
22808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22809       };
22810     } catch (...) {
22811       {
22812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22813       };
22814     }
22815   }
22816
22817   jresult = (void *)result;
22818
22819   //argout typemap for const std::string&
22820
22821   return jresult;
22822 }
22823
22824
22825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22826   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22827
22828   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22829   {
22830     try {
22831       delete arg1;
22832     } catch (std::out_of_range& e) {
22833       {
22834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22835       };
22836     } catch (std::exception& e) {
22837       {
22838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22839       };
22840     } catch (Dali::DaliException e) {
22841       {
22842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22843       };
22844     } catch (...) {
22845       {
22846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22847       };
22848     }
22849   }
22850
22851 }
22852
22853
22854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22855   unsigned int jresult ;
22856   std::string *arg1 = 0 ;
22857   std::type_info *arg2 = 0 ;
22858   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22859   bool result;
22860
22861   if (!jarg1) {
22862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22863     return 0;
22864   }
22865   std::string arg1_str(jarg1);
22866   arg1 = &arg1_str;
22867   arg2 = (std::type_info *)jarg2;
22868   if (!arg2) {
22869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22870     return 0;
22871   }
22872   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22873   {
22874     try {
22875       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22876     } catch (std::out_of_range& e) {
22877       {
22878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22879       };
22880     } catch (std::exception& e) {
22881       {
22882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22883       };
22884     } catch (Dali::DaliException e) {
22885       {
22886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22887       };
22888     } catch (...) {
22889       {
22890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22891       };
22892     }
22893   }
22894
22895   jresult = result;
22896
22897   //argout typemap for const std::string&
22898
22899   return jresult;
22900 }
22901
22902
22903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22904   unsigned int jresult ;
22905   std::string *arg1 = 0 ;
22906   std::string *arg2 = 0 ;
22907   Dali::Property::Index arg3 ;
22908   Dali::Property::Type arg4 ;
22909   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22910   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22911   bool result;
22912
22913   if (!jarg1) {
22914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22915     return 0;
22916   }
22917   std::string arg1_str(jarg1);
22918   arg1 = &arg1_str;
22919   if (!jarg2) {
22920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22921     return 0;
22922   }
22923   std::string arg2_str(jarg2);
22924   arg2 = &arg2_str;
22925   arg3 = (Dali::Property::Index)jarg3;
22926   arg4 = (Dali::Property::Type)jarg4;
22927   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22928   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22929   {
22930     try {
22931       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22932     } catch (std::out_of_range& e) {
22933       {
22934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22935       };
22936     } catch (std::exception& e) {
22937       {
22938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22939       };
22940     } catch (Dali::DaliException e) {
22941       {
22942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22943       };
22944     } catch (...) {
22945       {
22946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22947       };
22948     }
22949   }
22950
22951   jresult = result;
22952
22953   //argout typemap for const std::string&
22954
22955
22956   //argout typemap for const std::string&
22957
22958   return jresult;
22959 }
22960
22961
22962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22963   float jresult ;
22964   float result;
22965
22966   result = (float)(float)Dali::ParentOrigin::TOP;
22967   jresult = result;
22968   return jresult;
22969 }
22970
22971
22972 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22973   float jresult ;
22974   float result;
22975
22976   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22977   jresult = result;
22978   return jresult;
22979 }
22980
22981
22982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22983   float jresult ;
22984   float result;
22985
22986   result = (float)(float)Dali::ParentOrigin::LEFT;
22987   jresult = result;
22988   return jresult;
22989 }
22990
22991
22992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22993   float jresult ;
22994   float result;
22995
22996   result = (float)(float)Dali::ParentOrigin::RIGHT;
22997   jresult = result;
22998   return jresult;
22999 }
23000
23001
23002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
23003   float jresult ;
23004   float result;
23005
23006   result = (float)(float)Dali::ParentOrigin::MIDDLE;
23007   jresult = result;
23008   return jresult;
23009 }
23010
23011
23012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
23013   void * jresult ;
23014   Dali::Vector3 *result = 0 ;
23015
23016   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
23017   jresult = (void *)result;
23018   return jresult;
23019 }
23020
23021
23022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
23023   void * jresult ;
23024   Dali::Vector3 *result = 0 ;
23025
23026   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23027   jresult = (void *)result;
23028   return jresult;
23029 }
23030
23031
23032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23033   void * jresult ;
23034   Dali::Vector3 *result = 0 ;
23035
23036   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23037   jresult = (void *)result;
23038   return jresult;
23039 }
23040
23041
23042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23043   void * jresult ;
23044   Dali::Vector3 *result = 0 ;
23045
23046   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23047   jresult = (void *)result;
23048   return jresult;
23049 }
23050
23051
23052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23053   void * jresult ;
23054   Dali::Vector3 *result = 0 ;
23055
23056   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23057   jresult = (void *)result;
23058   return jresult;
23059 }
23060
23061
23062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23063   void * jresult ;
23064   Dali::Vector3 *result = 0 ;
23065
23066   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23067   jresult = (void *)result;
23068   return jresult;
23069 }
23070
23071
23072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23073   void * jresult ;
23074   Dali::Vector3 *result = 0 ;
23075
23076   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23077   jresult = (void *)result;
23078   return jresult;
23079 }
23080
23081
23082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23083   void * jresult ;
23084   Dali::Vector3 *result = 0 ;
23085
23086   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23087   jresult = (void *)result;
23088   return jresult;
23089 }
23090
23091
23092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23093   void * jresult ;
23094   Dali::Vector3 *result = 0 ;
23095
23096   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23097   jresult = (void *)result;
23098   return jresult;
23099 }
23100
23101
23102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23103   float jresult ;
23104   float result;
23105
23106   result = (float)(float)Dali::AnchorPoint::TOP;
23107   jresult = result;
23108   return jresult;
23109 }
23110
23111
23112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23113   float jresult ;
23114   float result;
23115
23116   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23117   jresult = result;
23118   return jresult;
23119 }
23120
23121
23122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23123   float jresult ;
23124   float result;
23125
23126   result = (float)(float)Dali::AnchorPoint::LEFT;
23127   jresult = result;
23128   return jresult;
23129 }
23130
23131
23132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23133   float jresult ;
23134   float result;
23135
23136   result = (float)(float)Dali::AnchorPoint::RIGHT;
23137   jresult = result;
23138   return jresult;
23139 }
23140
23141
23142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23143   float jresult ;
23144   float result;
23145
23146   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23147   jresult = result;
23148   return jresult;
23149 }
23150
23151
23152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23153   void * jresult ;
23154   Dali::Vector3 *result = 0 ;
23155
23156   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23157   jresult = (void *)result;
23158   return jresult;
23159 }
23160
23161
23162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23163   void * jresult ;
23164   Dali::Vector3 *result = 0 ;
23165
23166   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23167   jresult = (void *)result;
23168   return jresult;
23169 }
23170
23171
23172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23173   void * jresult ;
23174   Dali::Vector3 *result = 0 ;
23175
23176   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23177   jresult = (void *)result;
23178   return jresult;
23179 }
23180
23181
23182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23183   void * jresult ;
23184   Dali::Vector3 *result = 0 ;
23185
23186   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23187   jresult = (void *)result;
23188   return jresult;
23189 }
23190
23191
23192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23193   void * jresult ;
23194   Dali::Vector3 *result = 0 ;
23195
23196   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23197   jresult = (void *)result;
23198   return jresult;
23199 }
23200
23201
23202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23203   void * jresult ;
23204   Dali::Vector3 *result = 0 ;
23205
23206   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23207   jresult = (void *)result;
23208   return jresult;
23209 }
23210
23211
23212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23213   void * jresult ;
23214   Dali::Vector3 *result = 0 ;
23215
23216   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23217   jresult = (void *)result;
23218   return jresult;
23219 }
23220
23221
23222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23223   void * jresult ;
23224   Dali::Vector3 *result = 0 ;
23225
23226   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23227   jresult = (void *)result;
23228   return jresult;
23229 }
23230
23231
23232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23233   void * jresult ;
23234   Dali::Vector3 *result = 0 ;
23235
23236   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23237   jresult = (void *)result;
23238   return jresult;
23239 }
23240
23241
23242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23243   void * jresult ;
23244   Dali::Vector4 *result = 0 ;
23245
23246   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23247   jresult = (void *)result;
23248   return jresult;
23249 }
23250
23251
23252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23253   void * jresult ;
23254   Dali::Vector4 *result = 0 ;
23255
23256   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23257   jresult = (void *)result;
23258   return jresult;
23259 }
23260
23261
23262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23263   void * jresult ;
23264   Dali::Vector4 *result = 0 ;
23265
23266   result = (Dali::Vector4 *)&Dali::Color::RED;
23267   jresult = (void *)result;
23268   return jresult;
23269 }
23270
23271
23272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23273   void * jresult ;
23274   Dali::Vector4 *result = 0 ;
23275
23276   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23277   jresult = (void *)result;
23278   return jresult;
23279 }
23280
23281
23282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23283   void * jresult ;
23284   Dali::Vector4 *result = 0 ;
23285
23286   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23287   jresult = (void *)result;
23288   return jresult;
23289 }
23290
23291
23292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23293   void * jresult ;
23294   Dali::Vector4 *result = 0 ;
23295
23296   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23297   jresult = (void *)result;
23298   return jresult;
23299 }
23300
23301
23302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23303   void * jresult ;
23304   Dali::Vector4 *result = 0 ;
23305
23306   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23307   jresult = (void *)result;
23308   return jresult;
23309 }
23310
23311
23312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23313   void * jresult ;
23314   Dali::Vector4 *result = 0 ;
23315
23316   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23317   jresult = (void *)result;
23318   return jresult;
23319 }
23320
23321
23322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23323   void * jresult ;
23324   Dali::Vector4 *result = 0 ;
23325
23326   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23327   jresult = (void *)result;
23328   return jresult;
23329 }
23330
23331
23332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23333   float jresult ;
23334   float result;
23335
23336   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23337   jresult = result;
23338   return jresult;
23339 }
23340
23341
23342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23343   float jresult ;
23344   float result;
23345
23346   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23347   jresult = result;
23348   return jresult;
23349 }
23350
23351
23352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23353   float jresult ;
23354   float result;
23355
23356   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23357   jresult = result;
23358   return jresult;
23359 }
23360
23361
23362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23363   float jresult ;
23364   float result;
23365
23366   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23367   jresult = result;
23368   return jresult;
23369 }
23370
23371
23372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23373   float jresult ;
23374   float result;
23375
23376   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23377   jresult = result;
23378   return jresult;
23379 }
23380
23381
23382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23383   float jresult ;
23384   float result;
23385
23386   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23387   jresult = result;
23388   return jresult;
23389 }
23390
23391
23392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23393   float jresult ;
23394   float result;
23395
23396   result = (float)(float)Dali::Math::PI;
23397   jresult = result;
23398   return jresult;
23399 }
23400
23401
23402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23403   float jresult ;
23404   float result;
23405
23406   result = (float)(float)Dali::Math::PI_2;
23407   jresult = result;
23408   return jresult;
23409 }
23410
23411
23412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23413   float jresult ;
23414   float result;
23415
23416   result = (float)(float)Dali::Math::PI_4;
23417   jresult = result;
23418   return jresult;
23419 }
23420
23421
23422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23423   float jresult ;
23424   float result;
23425
23426   result = (float)(float)Dali::Math::PI_OVER_180;
23427   jresult = result;
23428   return jresult;
23429 }
23430
23431
23432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23433   float jresult ;
23434   float result;
23435
23436   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23437   jresult = result;
23438   return jresult;
23439 }
23440
23441
23442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23443   int jresult ;
23444   Dali::ResizePolicy::Type result;
23445
23446   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23447   jresult = (int)result;
23448   return jresult;
23449 }
23450
23451
23452 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23453   unsigned long jresult ;
23454   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23455   Dali::VectorBase::SizeType result;
23456
23457   arg1 = (Dali::VectorBase *)jarg1;
23458   {
23459     try {
23460       result = ((Dali::VectorBase const *)arg1)->Count();
23461     } catch (std::out_of_range& e) {
23462       {
23463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23464       };
23465     } catch (std::exception& e) {
23466       {
23467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23468       };
23469     } catch (Dali::DaliException e) {
23470       {
23471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23472       };
23473     } catch (...) {
23474       {
23475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23476       };
23477     }
23478   }
23479
23480   jresult = (unsigned long)result;
23481   return jresult;
23482 }
23483
23484
23485 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23486   unsigned long jresult ;
23487   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23488   Dali::VectorBase::SizeType result;
23489
23490   arg1 = (Dali::VectorBase *)jarg1;
23491   {
23492     try {
23493       result = ((Dali::VectorBase const *)arg1)->Size();
23494     } catch (std::out_of_range& e) {
23495       {
23496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23497       };
23498     } catch (std::exception& e) {
23499       {
23500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23501       };
23502     } catch (Dali::DaliException e) {
23503       {
23504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23505       };
23506     } catch (...) {
23507       {
23508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23509       };
23510     }
23511   }
23512
23513   jresult = (unsigned long)result;
23514   return jresult;
23515 }
23516
23517
23518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23519   unsigned int jresult ;
23520   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23521   bool result;
23522
23523   arg1 = (Dali::VectorBase *)jarg1;
23524   {
23525     try {
23526       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23527     } catch (std::out_of_range& e) {
23528       {
23529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23530       };
23531     } catch (std::exception& e) {
23532       {
23533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23534       };
23535     } catch (Dali::DaliException e) {
23536       {
23537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23538       };
23539     } catch (...) {
23540       {
23541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23542       };
23543     }
23544   }
23545
23546   jresult = result;
23547   return jresult;
23548 }
23549
23550
23551 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23552   unsigned long jresult ;
23553   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23554   Dali::VectorBase::SizeType result;
23555
23556   arg1 = (Dali::VectorBase *)jarg1;
23557   {
23558     try {
23559       result = ((Dali::VectorBase const *)arg1)->Capacity();
23560     } catch (std::out_of_range& e) {
23561       {
23562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23563       };
23564     } catch (std::exception& e) {
23565       {
23566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23567       };
23568     } catch (Dali::DaliException e) {
23569       {
23570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23571       };
23572     } catch (...) {
23573       {
23574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23575       };
23576     }
23577   }
23578
23579   jresult = (unsigned long)result;
23580   return jresult;
23581 }
23582
23583
23584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23585   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23586
23587   arg1 = (Dali::VectorBase *)jarg1;
23588   {
23589     try {
23590       (arg1)->Release();
23591     } catch (std::out_of_range& e) {
23592       {
23593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23594       };
23595     } catch (std::exception& e) {
23596       {
23597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23598       };
23599     } catch (Dali::DaliException e) {
23600       {
23601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23602       };
23603     } catch (...) {
23604       {
23605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23606       };
23607     }
23608   }
23609
23610 }
23611
23612
23613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23614   int jresult ;
23615   Dali::Pixel::Format result;
23616
23617   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23618   jresult = (int)result;
23619   return jresult;
23620 }
23621
23622
23623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23624   int jresult ;
23625   Dali::Pixel::Format result;
23626
23627   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23628   jresult = (int)result;
23629   return jresult;
23630 }
23631
23632
23633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23634   unsigned int jresult ;
23635   Dali::Pixel::Format arg1 ;
23636   bool result;
23637
23638   arg1 = (Dali::Pixel::Format)jarg1;
23639   {
23640     try {
23641       result = (bool)Dali::Pixel::HasAlpha(arg1);
23642     } catch (std::out_of_range& e) {
23643       {
23644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23645       };
23646     } catch (std::exception& e) {
23647       {
23648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23649       };
23650     } catch (Dali::DaliException e) {
23651       {
23652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23653       };
23654     } catch (...) {
23655       {
23656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23657       };
23658     }
23659   }
23660
23661   jresult = result;
23662   return jresult;
23663 }
23664
23665
23666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23667   unsigned int jresult ;
23668   Dali::Pixel::Format arg1 ;
23669   unsigned int result;
23670
23671   arg1 = (Dali::Pixel::Format)jarg1;
23672   {
23673     try {
23674       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23675     } catch (std::out_of_range& e) {
23676       {
23677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23678       };
23679     } catch (std::exception& e) {
23680       {
23681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23682       };
23683     } catch (Dali::DaliException e) {
23684       {
23685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23686       };
23687     } catch (...) {
23688       {
23689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23690       };
23691     }
23692   }
23693
23694   jresult = result;
23695   return jresult;
23696 }
23697
23698
23699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23700   Dali::Pixel::Format arg1 ;
23701   int *arg2 = 0 ;
23702   int *arg3 = 0 ;
23703
23704   arg1 = (Dali::Pixel::Format)jarg1;
23705   arg2 = (int *)jarg2;
23706   if (!arg2) {
23707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23708     return ;
23709   }
23710   arg3 = (int *)jarg3;
23711   if (!arg3) {
23712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23713     return ;
23714   }
23715   {
23716     try {
23717       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23718     } catch (std::out_of_range& e) {
23719       {
23720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23721       };
23722     } catch (std::exception& e) {
23723       {
23724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23725       };
23726     } catch (Dali::DaliException e) {
23727       {
23728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23729       };
23730     } catch (...) {
23731       {
23732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23733       };
23734     }
23735   }
23736
23737 }
23738
23739
23740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23741   void * jresult ;
23742   unsigned char *arg1 = (unsigned char *) 0 ;
23743   unsigned int arg2 ;
23744   unsigned int arg3 ;
23745   unsigned int arg4 ;
23746   Dali::Pixel::Format arg5 ;
23747   Dali::PixelData::ReleaseFunction arg6 ;
23748   Dali::PixelData result;
23749
23750   arg1 = jarg1;
23751   arg2 = (unsigned int)jarg2;
23752   arg3 = (unsigned int)jarg3;
23753   arg4 = (unsigned int)jarg4;
23754   arg5 = (Dali::Pixel::Format)jarg5;
23755   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23756   {
23757     try {
23758       auto pixelBuffer = new unsigned char[jarg2];
23759       memcpy( pixelBuffer, arg1, arg2);
23760       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23761     } catch (std::out_of_range& e) {
23762       {
23763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23764       };
23765     } catch (std::exception& e) {
23766       {
23767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23768       };
23769     } catch (Dali::DaliException e) {
23770       {
23771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23772       };
23773     } catch (...) {
23774       {
23775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23776       };
23777     }
23778   }
23779
23780   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23781
23782
23783   return jresult;
23784 }
23785
23786
23787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23788   void * jresult ;
23789   Dali::PixelData *result = 0 ;
23790
23791   {
23792     try {
23793       result = (Dali::PixelData *)new Dali::PixelData();
23794     } catch (std::out_of_range& e) {
23795       {
23796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23797       };
23798     } catch (std::exception& e) {
23799       {
23800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23801       };
23802     } catch (Dali::DaliException e) {
23803       {
23804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23805       };
23806     } catch (...) {
23807       {
23808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23809       };
23810     }
23811   }
23812
23813   jresult = (void *)result;
23814   return jresult;
23815 }
23816
23817
23818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23819   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23820
23821   arg1 = (Dali::PixelData *)jarg1;
23822   {
23823     try {
23824       delete arg1;
23825     } catch (std::out_of_range& e) {
23826       {
23827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23828       };
23829     } catch (std::exception& e) {
23830       {
23831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23832       };
23833     } catch (Dali::DaliException e) {
23834       {
23835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23836       };
23837     } catch (...) {
23838       {
23839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23840       };
23841     }
23842   }
23843
23844 }
23845
23846
23847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23848   void * jresult ;
23849   Dali::PixelData *arg1 = 0 ;
23850   Dali::PixelData *result = 0 ;
23851
23852   arg1 = (Dali::PixelData *)jarg1;
23853   if (!arg1) {
23854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23855     return 0;
23856   }
23857   {
23858     try {
23859       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23860     } catch (std::out_of_range& e) {
23861       {
23862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23863       };
23864     } catch (std::exception& e) {
23865       {
23866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23867       };
23868     } catch (Dali::DaliException e) {
23869       {
23870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23871       };
23872     } catch (...) {
23873       {
23874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23875       };
23876     }
23877   }
23878
23879   jresult = (void *)result;
23880   return jresult;
23881 }
23882
23883
23884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23885   void * jresult ;
23886   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23887   Dali::PixelData *arg2 = 0 ;
23888   Dali::PixelData *result = 0 ;
23889
23890   arg1 = (Dali::PixelData *)jarg1;
23891   arg2 = (Dali::PixelData *)jarg2;
23892   if (!arg2) {
23893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23894     return 0;
23895   }
23896   {
23897     try {
23898       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23899     } catch (std::out_of_range& e) {
23900       {
23901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23902       };
23903     } catch (std::exception& e) {
23904       {
23905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23906       };
23907     } catch (Dali::DaliException e) {
23908       {
23909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23910       };
23911     } catch (...) {
23912       {
23913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23914       };
23915     }
23916   }
23917
23918   jresult = (void *)result;
23919   return jresult;
23920 }
23921
23922
23923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23924   unsigned int jresult ;
23925   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23926   unsigned int result;
23927
23928   arg1 = (Dali::PixelData *)jarg1;
23929   {
23930     try {
23931       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23932     } catch (std::out_of_range& e) {
23933       {
23934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23935       };
23936     } catch (std::exception& e) {
23937       {
23938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23939       };
23940     } catch (Dali::DaliException e) {
23941       {
23942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23943       };
23944     } catch (...) {
23945       {
23946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23947       };
23948     }
23949   }
23950
23951   jresult = result;
23952   return jresult;
23953 }
23954
23955
23956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23957   unsigned int jresult ;
23958   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23959   unsigned int result;
23960
23961   arg1 = (Dali::PixelData *)jarg1;
23962   {
23963     try {
23964       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23965     } catch (std::out_of_range& e) {
23966       {
23967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23968       };
23969     } catch (std::exception& e) {
23970       {
23971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23972       };
23973     } catch (Dali::DaliException e) {
23974       {
23975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23976       };
23977     } catch (...) {
23978       {
23979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23980       };
23981     }
23982   }
23983
23984   jresult = result;
23985   return jresult;
23986 }
23987
23988
23989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23990   int jresult ;
23991   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23992   Dali::Pixel::Format result;
23993
23994   arg1 = (Dali::PixelData *)jarg1;
23995   {
23996     try {
23997       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
23998     } catch (std::out_of_range& e) {
23999       {
24000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24001       };
24002     } catch (std::exception& e) {
24003       {
24004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24005       };
24006     } catch (Dali::DaliException e) {
24007       {
24008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24009       };
24010     } catch (...) {
24011       {
24012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24013       };
24014     }
24015   }
24016
24017   jresult = (int)result;
24018   return jresult;
24019 }
24020
24021
24022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24023   unsigned int jresult ;
24024   unsigned int result;
24025
24026   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24027   jresult = result;
24028   return jresult;
24029 }
24030
24031
24032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24033   unsigned int jresult ;
24034   unsigned int result;
24035
24036   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24037   jresult = result;
24038   return jresult;
24039 }
24040
24041
24042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24043   unsigned int jresult ;
24044   unsigned int result;
24045
24046   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24047   jresult = result;
24048   return jresult;
24049 }
24050
24051
24052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24053   unsigned int jresult ;
24054   unsigned int result;
24055
24056   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24057   jresult = result;
24058   return jresult;
24059 }
24060
24061
24062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24063   unsigned int jresult ;
24064   unsigned int result;
24065
24066   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24067   jresult = result;
24068   return jresult;
24069 }
24070
24071
24072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24073   unsigned int jresult ;
24074   unsigned int result;
24075
24076   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24077   jresult = result;
24078   return jresult;
24079 }
24080
24081
24082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24083   void * jresult ;
24084   Dali::TextureType::Type arg1 ;
24085   Dali::Pixel::Format arg2 ;
24086   unsigned int arg3 ;
24087   unsigned int arg4 ;
24088   Dali::Texture result;
24089
24090   arg1 = (Dali::TextureType::Type)jarg1;
24091   arg2 = (Dali::Pixel::Format)jarg2;
24092   arg3 = (unsigned int)jarg3;
24093   arg4 = (unsigned int)jarg4;
24094   {
24095     try {
24096       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24097     } catch (std::out_of_range& e) {
24098       {
24099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24100       };
24101     } catch (std::exception& e) {
24102       {
24103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24104       };
24105     } catch (Dali::DaliException e) {
24106       {
24107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24108       };
24109     } catch (...) {
24110       {
24111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24112       };
24113     }
24114   }
24115
24116   jresult = new Dali::Texture((const Dali::Texture &)result);
24117   return jresult;
24118 }
24119
24120
24121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24122   void * jresult ;
24123   NativeImageInterface *arg1 = 0 ;
24124   Dali::Texture result;
24125
24126   arg1 = (NativeImageInterface *)jarg1;
24127   if (!arg1) {
24128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24129     return 0;
24130   }
24131   {
24132     try {
24133       result = Dali::Texture::New(*arg1);
24134     } catch (std::out_of_range& e) {
24135       {
24136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24137       };
24138     } catch (std::exception& e) {
24139       {
24140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24141       };
24142     } catch (Dali::DaliException e) {
24143       {
24144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24145       };
24146     } catch (...) {
24147       {
24148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24149       };
24150     }
24151   }
24152
24153   jresult = new Dali::Texture((const Dali::Texture &)result);
24154   return jresult;
24155 }
24156
24157
24158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24159   void * jresult ;
24160   Dali::Texture *result = 0 ;
24161
24162   {
24163     try {
24164       result = (Dali::Texture *)new Dali::Texture();
24165     } catch (std::out_of_range& e) {
24166       {
24167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24168       };
24169     } catch (std::exception& e) {
24170       {
24171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24172       };
24173     } catch (Dali::DaliException e) {
24174       {
24175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24176       };
24177     } catch (...) {
24178       {
24179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24180       };
24181     }
24182   }
24183
24184   jresult = (void *)result;
24185   return jresult;
24186 }
24187
24188
24189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24190   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24191
24192   arg1 = (Dali::Texture *)jarg1;
24193   {
24194     try {
24195       delete arg1;
24196     } catch (std::out_of_range& e) {
24197       {
24198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24199       };
24200     } catch (std::exception& e) {
24201       {
24202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24203       };
24204     } catch (Dali::DaliException e) {
24205       {
24206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24207       };
24208     } catch (...) {
24209       {
24210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24211       };
24212     }
24213   }
24214
24215 }
24216
24217
24218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24219   void * jresult ;
24220   Dali::Texture *arg1 = 0 ;
24221   Dali::Texture *result = 0 ;
24222
24223   arg1 = (Dali::Texture *)jarg1;
24224   if (!arg1) {
24225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24226     return 0;
24227   }
24228   {
24229     try {
24230       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24231     } catch (std::out_of_range& e) {
24232       {
24233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24234       };
24235     } catch (std::exception& e) {
24236       {
24237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24238       };
24239     } catch (Dali::DaliException e) {
24240       {
24241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24242       };
24243     } catch (...) {
24244       {
24245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24246       };
24247     }
24248   }
24249
24250   jresult = (void *)result;
24251   return jresult;
24252 }
24253
24254
24255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24256   void * jresult ;
24257   Dali::BaseHandle arg1 ;
24258   Dali::BaseHandle *argp1 ;
24259   Dali::Texture result;
24260
24261   argp1 = (Dali::BaseHandle *)jarg1;
24262   if (!argp1) {
24263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24264     return 0;
24265   }
24266   arg1 = *argp1;
24267   {
24268     try {
24269       result = Dali::Texture::DownCast(arg1);
24270     } catch (std::out_of_range& e) {
24271       {
24272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24273       };
24274     } catch (std::exception& e) {
24275       {
24276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24277       };
24278     } catch (Dali::DaliException e) {
24279       {
24280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24281       };
24282     } catch (...) {
24283       {
24284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24285       };
24286     }
24287   }
24288
24289   jresult = new Dali::Texture((const Dali::Texture &)result);
24290   return jresult;
24291 }
24292
24293
24294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24295   void * jresult ;
24296   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24297   Dali::Texture *arg2 = 0 ;
24298   Dali::Texture *result = 0 ;
24299
24300   arg1 = (Dali::Texture *)jarg1;
24301   arg2 = (Dali::Texture *)jarg2;
24302   if (!arg2) {
24303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24304     return 0;
24305   }
24306   {
24307     try {
24308       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24309     } catch (std::out_of_range& e) {
24310       {
24311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24312       };
24313     } catch (std::exception& e) {
24314       {
24315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24316       };
24317     } catch (Dali::DaliException e) {
24318       {
24319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24320       };
24321     } catch (...) {
24322       {
24323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24324       };
24325     }
24326   }
24327
24328   jresult = (void *)result;
24329   return jresult;
24330 }
24331
24332
24333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24334   unsigned int jresult ;
24335   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24336   Dali::PixelData arg2 ;
24337   Dali::PixelData *argp2 ;
24338   bool result;
24339
24340   arg1 = (Dali::Texture *)jarg1;
24341   argp2 = (Dali::PixelData *)jarg2;
24342   if (!argp2) {
24343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24344     return 0;
24345   }
24346   arg2 = *argp2;
24347   {
24348     try {
24349       result = (bool)(arg1)->Upload(arg2);
24350     } catch (std::out_of_range& e) {
24351       {
24352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24353       };
24354     } catch (std::exception& e) {
24355       {
24356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24357       };
24358     } catch (Dali::DaliException e) {
24359       {
24360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24361       };
24362     } catch (...) {
24363       {
24364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24365       };
24366     }
24367   }
24368
24369   jresult = result;
24370   return jresult;
24371 }
24372
24373
24374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
24375   unsigned int jresult ;
24376   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24377   Dali::PixelData arg2 ;
24378   unsigned int arg3 ;
24379   unsigned int arg4 ;
24380   unsigned int arg5 ;
24381   unsigned int arg6 ;
24382   unsigned int arg7 ;
24383   unsigned int arg8 ;
24384   Dali::PixelData *argp2 ;
24385   bool result;
24386
24387   arg1 = (Dali::Texture *)jarg1;
24388   argp2 = (Dali::PixelData *)jarg2;
24389   if (!argp2) {
24390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24391     return 0;
24392   }
24393   arg2 = *argp2;
24394   arg3 = (unsigned int)jarg3;
24395   arg4 = (unsigned int)jarg4;
24396   arg5 = (unsigned int)jarg5;
24397   arg6 = (unsigned int)jarg6;
24398   arg7 = (unsigned int)jarg7;
24399   arg8 = (unsigned int)jarg8;
24400   {
24401     try {
24402       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24403     } catch (std::out_of_range& e) {
24404       {
24405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24406       };
24407     } catch (std::exception& e) {
24408       {
24409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24410       };
24411     } catch (Dali::DaliException e) {
24412       {
24413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24414       };
24415     } catch (...) {
24416       {
24417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24418       };
24419     }
24420   }
24421
24422   jresult = result;
24423   return jresult;
24424 }
24425
24426
24427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24428   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24429
24430   arg1 = (Dali::Texture *)jarg1;
24431   {
24432     try {
24433       (arg1)->GenerateMipmaps();
24434     } catch (std::out_of_range& e) {
24435       {
24436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24437       };
24438     } catch (std::exception& e) {
24439       {
24440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24441       };
24442     } catch (Dali::DaliException e) {
24443       {
24444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24445       };
24446     } catch (...) {
24447       {
24448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24449       };
24450     }
24451   }
24452
24453 }
24454
24455
24456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24457   unsigned int jresult ;
24458   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24459   unsigned int result;
24460
24461   arg1 = (Dali::Texture *)jarg1;
24462   {
24463     try {
24464       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24465     } catch (std::out_of_range& e) {
24466       {
24467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24468       };
24469     } catch (std::exception& e) {
24470       {
24471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24472       };
24473     } catch (Dali::DaliException e) {
24474       {
24475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24476       };
24477     } catch (...) {
24478       {
24479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24480       };
24481     }
24482   }
24483
24484   jresult = result;
24485   return jresult;
24486 }
24487
24488
24489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24490   unsigned int jresult ;
24491   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24492   unsigned int result;
24493
24494   arg1 = (Dali::Texture *)jarg1;
24495   {
24496     try {
24497       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24498     } catch (std::out_of_range& e) {
24499       {
24500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24501       };
24502     } catch (std::exception& e) {
24503       {
24504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24505       };
24506     } catch (Dali::DaliException e) {
24507       {
24508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24509       };
24510     } catch (...) {
24511       {
24512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24513       };
24514     }
24515   }
24516
24517   jresult = result;
24518   return jresult;
24519 }
24520
24521
24522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24523   void * jresult ;
24524   Dali::Sampler result;
24525
24526   {
24527     try {
24528       result = Dali::Sampler::New();
24529     } catch (std::out_of_range& e) {
24530       {
24531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24532       };
24533     } catch (std::exception& e) {
24534       {
24535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24536       };
24537     } catch (Dali::DaliException e) {
24538       {
24539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24540       };
24541     } catch (...) {
24542       {
24543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24544       };
24545     }
24546   }
24547
24548   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24549   return jresult;
24550 }
24551
24552
24553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24554   void * jresult ;
24555   Dali::Sampler *result = 0 ;
24556
24557   {
24558     try {
24559       result = (Dali::Sampler *)new Dali::Sampler();
24560     } catch (std::out_of_range& e) {
24561       {
24562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24563       };
24564     } catch (std::exception& e) {
24565       {
24566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24567       };
24568     } catch (Dali::DaliException e) {
24569       {
24570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24571       };
24572     } catch (...) {
24573       {
24574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24575       };
24576     }
24577   }
24578
24579   jresult = (void *)result;
24580   return jresult;
24581 }
24582
24583
24584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24585   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24586
24587   arg1 = (Dali::Sampler *)jarg1;
24588   {
24589     try {
24590       delete arg1;
24591     } catch (std::out_of_range& e) {
24592       {
24593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24594       };
24595     } catch (std::exception& e) {
24596       {
24597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24598       };
24599     } catch (Dali::DaliException e) {
24600       {
24601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24602       };
24603     } catch (...) {
24604       {
24605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24606       };
24607     }
24608   }
24609
24610 }
24611
24612
24613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24614   void * jresult ;
24615   Dali::Sampler *arg1 = 0 ;
24616   Dali::Sampler *result = 0 ;
24617
24618   arg1 = (Dali::Sampler *)jarg1;
24619   if (!arg1) {
24620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24621     return 0;
24622   }
24623   {
24624     try {
24625       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24626     } catch (std::out_of_range& e) {
24627       {
24628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24629       };
24630     } catch (std::exception& e) {
24631       {
24632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24633       };
24634     } catch (Dali::DaliException e) {
24635       {
24636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24637       };
24638     } catch (...) {
24639       {
24640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24641       };
24642     }
24643   }
24644
24645   jresult = (void *)result;
24646   return jresult;
24647 }
24648
24649
24650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24651   void * jresult ;
24652   Dali::BaseHandle arg1 ;
24653   Dali::BaseHandle *argp1 ;
24654   Dali::Sampler result;
24655
24656   argp1 = (Dali::BaseHandle *)jarg1;
24657   if (!argp1) {
24658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24659     return 0;
24660   }
24661   arg1 = *argp1;
24662   {
24663     try {
24664       result = Dali::Sampler::DownCast(arg1);
24665     } catch (std::out_of_range& e) {
24666       {
24667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24668       };
24669     } catch (std::exception& e) {
24670       {
24671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24672       };
24673     } catch (Dali::DaliException e) {
24674       {
24675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24676       };
24677     } catch (...) {
24678       {
24679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24680       };
24681     }
24682   }
24683
24684   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24685   return jresult;
24686 }
24687
24688
24689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24690   void * jresult ;
24691   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24692   Dali::Sampler *arg2 = 0 ;
24693   Dali::Sampler *result = 0 ;
24694
24695   arg1 = (Dali::Sampler *)jarg1;
24696   arg2 = (Dali::Sampler *)jarg2;
24697   if (!arg2) {
24698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24699     return 0;
24700   }
24701   {
24702     try {
24703       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24704     } catch (std::out_of_range& e) {
24705       {
24706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24707       };
24708     } catch (std::exception& e) {
24709       {
24710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24711       };
24712     } catch (Dali::DaliException e) {
24713       {
24714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24715       };
24716     } catch (...) {
24717       {
24718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24719       };
24720     }
24721   }
24722
24723   jresult = (void *)result;
24724   return jresult;
24725 }
24726
24727
24728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24729   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24730   Dali::FilterMode::Type arg2 ;
24731   Dali::FilterMode::Type arg3 ;
24732
24733   arg1 = (Dali::Sampler *)jarg1;
24734   arg2 = (Dali::FilterMode::Type)jarg2;
24735   arg3 = (Dali::FilterMode::Type)jarg3;
24736   {
24737     try {
24738       (arg1)->SetFilterMode(arg2,arg3);
24739     } catch (std::out_of_range& e) {
24740       {
24741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24742       };
24743     } catch (std::exception& e) {
24744       {
24745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24746       };
24747     } catch (Dali::DaliException e) {
24748       {
24749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24750       };
24751     } catch (...) {
24752       {
24753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24754       };
24755     }
24756   }
24757
24758 }
24759
24760
24761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24762   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24763   Dali::WrapMode::Type arg2 ;
24764   Dali::WrapMode::Type arg3 ;
24765
24766   arg1 = (Dali::Sampler *)jarg1;
24767   arg2 = (Dali::WrapMode::Type)jarg2;
24768   arg3 = (Dali::WrapMode::Type)jarg3;
24769   {
24770     try {
24771       (arg1)->SetWrapMode(arg2,arg3);
24772     } catch (std::out_of_range& e) {
24773       {
24774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24775       };
24776     } catch (std::exception& e) {
24777       {
24778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24779       };
24780     } catch (Dali::DaliException e) {
24781       {
24782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24783       };
24784     } catch (...) {
24785       {
24786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24787       };
24788     }
24789   }
24790
24791 }
24792
24793
24794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24795   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24796   Dali::WrapMode::Type arg2 ;
24797   Dali::WrapMode::Type arg3 ;
24798   Dali::WrapMode::Type arg4 ;
24799
24800   arg1 = (Dali::Sampler *)jarg1;
24801   arg2 = (Dali::WrapMode::Type)jarg2;
24802   arg3 = (Dali::WrapMode::Type)jarg3;
24803   arg4 = (Dali::WrapMode::Type)jarg4;
24804   {
24805     try {
24806       (arg1)->SetWrapMode(arg2,arg3,arg4);
24807     } catch (std::out_of_range& e) {
24808       {
24809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24810       };
24811     } catch (std::exception& e) {
24812       {
24813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24814       };
24815     } catch (Dali::DaliException e) {
24816       {
24817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24818       };
24819     } catch (...) {
24820       {
24821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24822       };
24823     }
24824   }
24825
24826 }
24827
24828
24829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24830   void * jresult ;
24831   Dali::TextureSet result;
24832
24833   {
24834     try {
24835       result = Dali::TextureSet::New();
24836     } catch (std::out_of_range& e) {
24837       {
24838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24839       };
24840     } catch (std::exception& e) {
24841       {
24842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24843       };
24844     } catch (Dali::DaliException e) {
24845       {
24846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24847       };
24848     } catch (...) {
24849       {
24850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24851       };
24852     }
24853   }
24854
24855   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24856   return jresult;
24857 }
24858
24859
24860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24861   void * jresult ;
24862   Dali::TextureSet *result = 0 ;
24863
24864   {
24865     try {
24866       result = (Dali::TextureSet *)new Dali::TextureSet();
24867     } catch (std::out_of_range& e) {
24868       {
24869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24870       };
24871     } catch (std::exception& e) {
24872       {
24873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24874       };
24875     } catch (Dali::DaliException e) {
24876       {
24877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24878       };
24879     } catch (...) {
24880       {
24881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24882       };
24883     }
24884   }
24885
24886   jresult = (void *)result;
24887   return jresult;
24888 }
24889
24890
24891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24892   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24893
24894   arg1 = (Dali::TextureSet *)jarg1;
24895   {
24896     try {
24897       delete arg1;
24898     } catch (std::out_of_range& e) {
24899       {
24900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24901       };
24902     } catch (std::exception& e) {
24903       {
24904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24905       };
24906     } catch (Dali::DaliException e) {
24907       {
24908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24909       };
24910     } catch (...) {
24911       {
24912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24913       };
24914     }
24915   }
24916
24917 }
24918
24919
24920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24921   void * jresult ;
24922   Dali::TextureSet *arg1 = 0 ;
24923   Dali::TextureSet *result = 0 ;
24924
24925   arg1 = (Dali::TextureSet *)jarg1;
24926   if (!arg1) {
24927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24928     return 0;
24929   }
24930   {
24931     try {
24932       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24933     } catch (std::out_of_range& e) {
24934       {
24935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24936       };
24937     } catch (std::exception& e) {
24938       {
24939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24940       };
24941     } catch (Dali::DaliException e) {
24942       {
24943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24944       };
24945     } catch (...) {
24946       {
24947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24948       };
24949     }
24950   }
24951
24952   jresult = (void *)result;
24953   return jresult;
24954 }
24955
24956
24957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24958   void * jresult ;
24959   Dali::BaseHandle arg1 ;
24960   Dali::BaseHandle *argp1 ;
24961   Dali::TextureSet result;
24962
24963   argp1 = (Dali::BaseHandle *)jarg1;
24964   if (!argp1) {
24965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24966     return 0;
24967   }
24968   arg1 = *argp1;
24969   {
24970     try {
24971       result = Dali::TextureSet::DownCast(arg1);
24972     } catch (std::out_of_range& e) {
24973       {
24974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24975       };
24976     } catch (std::exception& e) {
24977       {
24978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24979       };
24980     } catch (Dali::DaliException e) {
24981       {
24982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24983       };
24984     } catch (...) {
24985       {
24986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24987       };
24988     }
24989   }
24990
24991   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24992   return jresult;
24993 }
24994
24995
24996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
24997   void * jresult ;
24998   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24999   Dali::TextureSet *arg2 = 0 ;
25000   Dali::TextureSet *result = 0 ;
25001
25002   arg1 = (Dali::TextureSet *)jarg1;
25003   arg2 = (Dali::TextureSet *)jarg2;
25004   if (!arg2) {
25005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25006     return 0;
25007   }
25008   {
25009     try {
25010       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25011     } catch (std::out_of_range& e) {
25012       {
25013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25014       };
25015     } catch (std::exception& e) {
25016       {
25017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25018       };
25019     } catch (Dali::DaliException e) {
25020       {
25021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25022       };
25023     } catch (...) {
25024       {
25025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25026       };
25027     }
25028   }
25029
25030   jresult = (void *)result;
25031   return jresult;
25032 }
25033
25034
25035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25036   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25037   size_t arg2 ;
25038   Dali::Texture arg3 ;
25039   Dali::Texture *argp3 ;
25040
25041   arg1 = (Dali::TextureSet *)jarg1;
25042   arg2 = (size_t)jarg2;
25043   argp3 = (Dali::Texture *)jarg3;
25044   if (!argp3) {
25045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25046     return ;
25047   }
25048   arg3 = *argp3;
25049   {
25050     try {
25051       (arg1)->SetTexture(arg2,arg3);
25052     } catch (std::out_of_range& e) {
25053       {
25054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25055       };
25056     } catch (std::exception& e) {
25057       {
25058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25059       };
25060     } catch (Dali::DaliException e) {
25061       {
25062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25063       };
25064     } catch (...) {
25065       {
25066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25067       };
25068     }
25069   }
25070
25071 }
25072
25073
25074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25075   void * jresult ;
25076   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25077   size_t arg2 ;
25078   Dali::Texture result;
25079
25080   arg1 = (Dali::TextureSet *)jarg1;
25081   arg2 = (size_t)jarg2;
25082   {
25083     try {
25084       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25085     } catch (std::out_of_range& e) {
25086       {
25087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25088       };
25089     } catch (std::exception& e) {
25090       {
25091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25092       };
25093     } catch (Dali::DaliException e) {
25094       {
25095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25096       };
25097     } catch (...) {
25098       {
25099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25100       };
25101     }
25102   }
25103
25104   jresult = new Dali::Texture((const Dali::Texture &)result);
25105   return jresult;
25106 }
25107
25108
25109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25110   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25111   size_t arg2 ;
25112   Dali::Sampler arg3 ;
25113   Dali::Sampler *argp3 ;
25114
25115   arg1 = (Dali::TextureSet *)jarg1;
25116   arg2 = (size_t)jarg2;
25117   argp3 = (Dali::Sampler *)jarg3;
25118   if (!argp3) {
25119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25120     return ;
25121   }
25122   arg3 = *argp3;
25123   {
25124     try {
25125       (arg1)->SetSampler(arg2,arg3);
25126     } catch (std::out_of_range& e) {
25127       {
25128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25129       };
25130     } catch (std::exception& e) {
25131       {
25132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25133       };
25134     } catch (Dali::DaliException e) {
25135       {
25136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25137       };
25138     } catch (...) {
25139       {
25140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25141       };
25142     }
25143   }
25144
25145 }
25146
25147
25148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25149   void * jresult ;
25150   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25151   size_t arg2 ;
25152   Dali::Sampler result;
25153
25154   arg1 = (Dali::TextureSet *)jarg1;
25155   arg2 = (size_t)jarg2;
25156   {
25157     try {
25158       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25159     } catch (std::out_of_range& e) {
25160       {
25161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25162       };
25163     } catch (std::exception& e) {
25164       {
25165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25166       };
25167     } catch (Dali::DaliException e) {
25168       {
25169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25170       };
25171     } catch (...) {
25172       {
25173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25174       };
25175     }
25176   }
25177
25178   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25179   return jresult;
25180 }
25181
25182
25183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25184   unsigned long jresult ;
25185   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25186   size_t result;
25187
25188   arg1 = (Dali::TextureSet *)jarg1;
25189   {
25190     try {
25191       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25192     } catch (std::out_of_range& e) {
25193       {
25194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25195       };
25196     } catch (std::exception& e) {
25197       {
25198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25199       };
25200     } catch (Dali::DaliException e) {
25201       {
25202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25203       };
25204     } catch (...) {
25205       {
25206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25207       };
25208     }
25209   }
25210
25211   jresult = (unsigned long)result;
25212   return jresult;
25213 }
25214
25215
25216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25217   void * jresult ;
25218   Dali::Property::Map *arg1 = 0 ;
25219   Dali::PropertyBuffer result;
25220
25221   arg1 = (Dali::Property::Map *)jarg1;
25222   if (!arg1) {
25223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25224     return 0;
25225   }
25226   {
25227     try {
25228       result = Dali::PropertyBuffer::New(*arg1);
25229     } catch (std::out_of_range& e) {
25230       {
25231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25232       };
25233     } catch (std::exception& e) {
25234       {
25235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25236       };
25237     } catch (Dali::DaliException e) {
25238       {
25239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25240       };
25241     } catch (...) {
25242       {
25243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25244       };
25245     }
25246   }
25247
25248   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25249   return jresult;
25250 }
25251
25252
25253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25254   void * jresult ;
25255   Dali::PropertyBuffer *result = 0 ;
25256
25257   {
25258     try {
25259       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25260     } catch (std::out_of_range& e) {
25261       {
25262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25263       };
25264     } catch (std::exception& e) {
25265       {
25266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25267       };
25268     } catch (Dali::DaliException e) {
25269       {
25270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25271       };
25272     } catch (...) {
25273       {
25274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25275       };
25276     }
25277   }
25278
25279   jresult = (void *)result;
25280   return jresult;
25281 }
25282
25283
25284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25285   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25286
25287   arg1 = (Dali::PropertyBuffer *)jarg1;
25288   {
25289     try {
25290       delete arg1;
25291     } catch (std::out_of_range& e) {
25292       {
25293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25294       };
25295     } catch (std::exception& e) {
25296       {
25297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25298       };
25299     } catch (Dali::DaliException e) {
25300       {
25301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25302       };
25303     } catch (...) {
25304       {
25305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25306       };
25307     }
25308   }
25309
25310 }
25311
25312
25313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25314   void * jresult ;
25315   Dali::PropertyBuffer *arg1 = 0 ;
25316   Dali::PropertyBuffer *result = 0 ;
25317
25318   arg1 = (Dali::PropertyBuffer *)jarg1;
25319   if (!arg1) {
25320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25321     return 0;
25322   }
25323   {
25324     try {
25325       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25326     } catch (std::out_of_range& e) {
25327       {
25328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25329       };
25330     } catch (std::exception& e) {
25331       {
25332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25333       };
25334     } catch (Dali::DaliException e) {
25335       {
25336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25337       };
25338     } catch (...) {
25339       {
25340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25341       };
25342     }
25343   }
25344
25345   jresult = (void *)result;
25346   return jresult;
25347 }
25348
25349
25350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25351   void * jresult ;
25352   Dali::BaseHandle arg1 ;
25353   Dali::BaseHandle *argp1 ;
25354   Dali::PropertyBuffer result;
25355
25356   argp1 = (Dali::BaseHandle *)jarg1;
25357   if (!argp1) {
25358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25359     return 0;
25360   }
25361   arg1 = *argp1;
25362   {
25363     try {
25364       result = Dali::PropertyBuffer::DownCast(arg1);
25365     } catch (std::out_of_range& e) {
25366       {
25367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25368       };
25369     } catch (std::exception& e) {
25370       {
25371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25372       };
25373     } catch (Dali::DaliException e) {
25374       {
25375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25376       };
25377     } catch (...) {
25378       {
25379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25380       };
25381     }
25382   }
25383
25384   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25385   return jresult;
25386 }
25387
25388
25389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25390   void * jresult ;
25391   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25392   Dali::PropertyBuffer *arg2 = 0 ;
25393   Dali::PropertyBuffer *result = 0 ;
25394
25395   arg1 = (Dali::PropertyBuffer *)jarg1;
25396   arg2 = (Dali::PropertyBuffer *)jarg2;
25397   if (!arg2) {
25398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25399     return 0;
25400   }
25401   {
25402     try {
25403       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25404     } catch (std::out_of_range& e) {
25405       {
25406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25407       };
25408     } catch (std::exception& e) {
25409       {
25410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25411       };
25412     } catch (Dali::DaliException e) {
25413       {
25414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25415       };
25416     } catch (...) {
25417       {
25418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25419       };
25420     }
25421   }
25422
25423   jresult = (void *)result;
25424   return jresult;
25425 }
25426
25427
25428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25429   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25430   void *arg2 = (void *) 0 ;
25431   std::size_t arg3 ;
25432
25433   arg1 = (Dali::PropertyBuffer *)jarg1;
25434   arg2 = jarg2;
25435   arg3 = (std::size_t)jarg3;
25436   {
25437     try {
25438       (arg1)->SetData((void const *)arg2,arg3);
25439     } catch (std::out_of_range& e) {
25440       {
25441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25442       };
25443     } catch (std::exception& e) {
25444       {
25445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25446       };
25447     } catch (Dali::DaliException e) {
25448       {
25449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25450       };
25451     } catch (...) {
25452       {
25453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25454       };
25455     }
25456   }
25457
25458 }
25459
25460
25461 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25462   unsigned long jresult ;
25463   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25464   std::size_t result;
25465
25466   arg1 = (Dali::PropertyBuffer *)jarg1;
25467   {
25468     try {
25469       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25470     } catch (std::out_of_range& e) {
25471       {
25472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25473       };
25474     } catch (std::exception& e) {
25475       {
25476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25477       };
25478     } catch (Dali::DaliException e) {
25479       {
25480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25481       };
25482     } catch (...) {
25483       {
25484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25485       };
25486     }
25487   }
25488
25489   jresult = (unsigned long)result;
25490   return jresult;
25491 }
25492
25493
25494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25495   void * jresult ;
25496   Dali::Geometry result;
25497
25498   {
25499     try {
25500       result = Dali::Geometry::New();
25501     } catch (std::out_of_range& e) {
25502       {
25503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25504       };
25505     } catch (std::exception& e) {
25506       {
25507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25508       };
25509     } catch (Dali::DaliException e) {
25510       {
25511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25512       };
25513     } catch (...) {
25514       {
25515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25516       };
25517     }
25518   }
25519
25520   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25521   return jresult;
25522 }
25523
25524
25525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25526   void * jresult ;
25527   Dali::Geometry *result = 0 ;
25528
25529   {
25530     try {
25531       result = (Dali::Geometry *)new Dali::Geometry();
25532     } catch (std::out_of_range& e) {
25533       {
25534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25535       };
25536     } catch (std::exception& e) {
25537       {
25538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25539       };
25540     } catch (Dali::DaliException e) {
25541       {
25542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25543       };
25544     } catch (...) {
25545       {
25546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25547       };
25548     }
25549   }
25550
25551   jresult = (void *)result;
25552   return jresult;
25553 }
25554
25555
25556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25557   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25558
25559   arg1 = (Dali::Geometry *)jarg1;
25560   {
25561     try {
25562       delete arg1;
25563     } catch (std::out_of_range& e) {
25564       {
25565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25566       };
25567     } catch (std::exception& e) {
25568       {
25569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25570       };
25571     } catch (Dali::DaliException e) {
25572       {
25573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25574       };
25575     } catch (...) {
25576       {
25577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25578       };
25579     }
25580   }
25581
25582 }
25583
25584
25585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25586   void * jresult ;
25587   Dali::Geometry *arg1 = 0 ;
25588   Dali::Geometry *result = 0 ;
25589
25590   arg1 = (Dali::Geometry *)jarg1;
25591   if (!arg1) {
25592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25593     return 0;
25594   }
25595   {
25596     try {
25597       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25598     } catch (std::out_of_range& e) {
25599       {
25600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25601       };
25602     } catch (std::exception& e) {
25603       {
25604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25605       };
25606     } catch (Dali::DaliException e) {
25607       {
25608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25609       };
25610     } catch (...) {
25611       {
25612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25613       };
25614     }
25615   }
25616
25617   jresult = (void *)result;
25618   return jresult;
25619 }
25620
25621
25622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25623   void * jresult ;
25624   Dali::BaseHandle arg1 ;
25625   Dali::BaseHandle *argp1 ;
25626   Dali::Geometry result;
25627
25628   argp1 = (Dali::BaseHandle *)jarg1;
25629   if (!argp1) {
25630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25631     return 0;
25632   }
25633   arg1 = *argp1;
25634   {
25635     try {
25636       result = Dali::Geometry::DownCast(arg1);
25637     } catch (std::out_of_range& e) {
25638       {
25639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25640       };
25641     } catch (std::exception& e) {
25642       {
25643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25644       };
25645     } catch (Dali::DaliException e) {
25646       {
25647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25648       };
25649     } catch (...) {
25650       {
25651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25652       };
25653     }
25654   }
25655
25656   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25657   return jresult;
25658 }
25659
25660
25661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25662   void * jresult ;
25663   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25664   Dali::Geometry *arg2 = 0 ;
25665   Dali::Geometry *result = 0 ;
25666
25667   arg1 = (Dali::Geometry *)jarg1;
25668   arg2 = (Dali::Geometry *)jarg2;
25669   if (!arg2) {
25670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25671     return 0;
25672   }
25673   {
25674     try {
25675       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25676     } catch (std::out_of_range& e) {
25677       {
25678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25679       };
25680     } catch (std::exception& e) {
25681       {
25682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25683       };
25684     } catch (Dali::DaliException e) {
25685       {
25686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25687       };
25688     } catch (...) {
25689       {
25690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25691       };
25692     }
25693   }
25694
25695   jresult = (void *)result;
25696   return jresult;
25697 }
25698
25699
25700 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25701   unsigned long jresult ;
25702   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25703   Dali::PropertyBuffer *arg2 = 0 ;
25704   std::size_t result;
25705
25706   arg1 = (Dali::Geometry *)jarg1;
25707   arg2 = (Dali::PropertyBuffer *)jarg2;
25708   if (!arg2) {
25709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25710     return 0;
25711   }
25712   {
25713     try {
25714       result = (arg1)->AddVertexBuffer(*arg2);
25715     } catch (std::out_of_range& e) {
25716       {
25717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25718       };
25719     } catch (std::exception& e) {
25720       {
25721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25722       };
25723     } catch (Dali::DaliException e) {
25724       {
25725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25726       };
25727     } catch (...) {
25728       {
25729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25730       };
25731     }
25732   }
25733
25734   jresult = (unsigned long)result;
25735   return jresult;
25736 }
25737
25738
25739 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25740   unsigned long jresult ;
25741   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25742   std::size_t result;
25743
25744   arg1 = (Dali::Geometry *)jarg1;
25745   {
25746     try {
25747       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25748     } catch (std::out_of_range& e) {
25749       {
25750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25751       };
25752     } catch (std::exception& e) {
25753       {
25754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25755       };
25756     } catch (Dali::DaliException e) {
25757       {
25758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25759       };
25760     } catch (...) {
25761       {
25762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25763       };
25764     }
25765   }
25766
25767   jresult = (unsigned long)result;
25768   return jresult;
25769 }
25770
25771
25772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25773   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25774   std::size_t arg2 ;
25775
25776   arg1 = (Dali::Geometry *)jarg1;
25777   arg2 = (std::size_t)jarg2;
25778   {
25779     try {
25780       (arg1)->RemoveVertexBuffer(arg2);
25781     } catch (std::out_of_range& e) {
25782       {
25783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25784       };
25785     } catch (std::exception& e) {
25786       {
25787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25788       };
25789     } catch (Dali::DaliException e) {
25790       {
25791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25792       };
25793     } catch (...) {
25794       {
25795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25796       };
25797     }
25798   }
25799
25800 }
25801
25802
25803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25804   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25805   unsigned short *arg2 = (unsigned short *) 0 ;
25806   size_t arg3 ;
25807
25808   arg1 = (Dali::Geometry *)jarg1;
25809   arg2 = jarg2;
25810   arg3 = (size_t)jarg3;
25811   {
25812     try {
25813       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25814     } catch (std::out_of_range& e) {
25815       {
25816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25817       };
25818     } catch (std::exception& e) {
25819       {
25820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25821       };
25822     } catch (Dali::DaliException e) {
25823       {
25824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25825       };
25826     } catch (...) {
25827       {
25828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25829       };
25830     }
25831   }
25832
25833
25834
25835 }
25836
25837
25838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25839   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25840   Dali::Geometry::Type arg2 ;
25841
25842   arg1 = (Dali::Geometry *)jarg1;
25843   arg2 = (Dali::Geometry::Type)jarg2;
25844   {
25845     try {
25846       (arg1)->SetType(arg2);
25847     } catch (std::out_of_range& e) {
25848       {
25849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25850       };
25851     } catch (std::exception& e) {
25852       {
25853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25854       };
25855     } catch (Dali::DaliException e) {
25856       {
25857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25858       };
25859     } catch (...) {
25860       {
25861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25862       };
25863     }
25864   }
25865
25866 }
25867
25868
25869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25870   int jresult ;
25871   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25872   Dali::Geometry::Type result;
25873
25874   arg1 = (Dali::Geometry *)jarg1;
25875   {
25876     try {
25877       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25878     } catch (std::out_of_range& e) {
25879       {
25880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25881       };
25882     } catch (std::exception& e) {
25883       {
25884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25885       };
25886     } catch (Dali::DaliException e) {
25887       {
25888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25889       };
25890     } catch (...) {
25891       {
25892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25893       };
25894     }
25895   }
25896
25897   jresult = (int)result;
25898   return jresult;
25899 }
25900
25901
25902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25903   void * jresult ;
25904   Dali::Shader::Hint *result = 0 ;
25905
25906   {
25907     try {
25908       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25909     } catch (std::out_of_range& e) {
25910       {
25911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25912       };
25913     } catch (std::exception& e) {
25914       {
25915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25916       };
25917     } catch (Dali::DaliException e) {
25918       {
25919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25920       };
25921     } catch (...) {
25922       {
25923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25924       };
25925     }
25926   }
25927
25928   jresult = (void *)result;
25929   return jresult;
25930 }
25931
25932
25933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25934   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25935
25936   arg1 = (Dali::Shader::Hint *)jarg1;
25937   {
25938     try {
25939       delete arg1;
25940     } catch (std::out_of_range& e) {
25941       {
25942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25943       };
25944     } catch (std::exception& e) {
25945       {
25946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25947       };
25948     } catch (Dali::DaliException e) {
25949       {
25950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25951       };
25952     } catch (...) {
25953       {
25954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25955       };
25956     }
25957   }
25958
25959 }
25960
25961
25962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25963   int jresult ;
25964   int result;
25965
25966   result = (int)Dali::Shader::Property::PROGRAM;
25967   jresult = (int)result;
25968   return jresult;
25969 }
25970
25971
25972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25973   void * jresult ;
25974   Dali::Shader::Property *result = 0 ;
25975
25976   {
25977     try {
25978       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25979     } catch (std::out_of_range& e) {
25980       {
25981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25982       };
25983     } catch (std::exception& e) {
25984       {
25985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25986       };
25987     } catch (Dali::DaliException e) {
25988       {
25989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25990       };
25991     } catch (...) {
25992       {
25993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25994       };
25995     }
25996   }
25997
25998   jresult = (void *)result;
25999   return jresult;
26000 }
26001
26002
26003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26004   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26005
26006   arg1 = (Dali::Shader::Property *)jarg1;
26007   {
26008     try {
26009       delete arg1;
26010     } catch (std::out_of_range& e) {
26011       {
26012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26013       };
26014     } catch (std::exception& e) {
26015       {
26016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26017       };
26018     } catch (Dali::DaliException e) {
26019       {
26020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26021       };
26022     } catch (...) {
26023       {
26024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26025       };
26026     }
26027   }
26028
26029 }
26030
26031
26032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26033   void * jresult ;
26034   std::string *arg1 = 0 ;
26035   std::string *arg2 = 0 ;
26036   Dali::Shader::Hint::Value arg3 ;
26037   Dali::Shader result;
26038
26039   if (!jarg1) {
26040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26041     return 0;
26042   }
26043   std::string arg1_str(jarg1);
26044   arg1 = &arg1_str;
26045   if (!jarg2) {
26046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26047     return 0;
26048   }
26049   std::string arg2_str(jarg2);
26050   arg2 = &arg2_str;
26051   arg3 = (Dali::Shader::Hint::Value)jarg3;
26052   {
26053     try {
26054       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26055     } catch (std::out_of_range& e) {
26056       {
26057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26058       };
26059     } catch (std::exception& e) {
26060       {
26061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26062       };
26063     } catch (Dali::DaliException e) {
26064       {
26065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26066       };
26067     } catch (...) {
26068       {
26069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26070       };
26071     }
26072   }
26073
26074   jresult = new Dali::Shader((const Dali::Shader &)result);
26075
26076   //argout typemap for const std::string&
26077
26078
26079   //argout typemap for const std::string&
26080
26081   return jresult;
26082 }
26083
26084
26085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26086   void * jresult ;
26087   std::string *arg1 = 0 ;
26088   std::string *arg2 = 0 ;
26089   Dali::Shader result;
26090
26091   if (!jarg1) {
26092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26093     return 0;
26094   }
26095   std::string arg1_str(jarg1);
26096   arg1 = &arg1_str;
26097   if (!jarg2) {
26098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26099     return 0;
26100   }
26101   std::string arg2_str(jarg2);
26102   arg2 = &arg2_str;
26103   {
26104     try {
26105       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26106     } catch (std::out_of_range& e) {
26107       {
26108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26109       };
26110     } catch (std::exception& e) {
26111       {
26112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26113       };
26114     } catch (Dali::DaliException e) {
26115       {
26116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26117       };
26118     } catch (...) {
26119       {
26120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26121       };
26122     }
26123   }
26124
26125   jresult = new Dali::Shader((const Dali::Shader &)result);
26126
26127   //argout typemap for const std::string&
26128
26129
26130   //argout typemap for const std::string&
26131
26132   return jresult;
26133 }
26134
26135
26136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26137   void * jresult ;
26138   Dali::Shader *result = 0 ;
26139
26140   {
26141     try {
26142       result = (Dali::Shader *)new Dali::Shader();
26143     } catch (std::out_of_range& e) {
26144       {
26145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26146       };
26147     } catch (std::exception& e) {
26148       {
26149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26150       };
26151     } catch (Dali::DaliException e) {
26152       {
26153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26154       };
26155     } catch (...) {
26156       {
26157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26158       };
26159     }
26160   }
26161
26162   jresult = (void *)result;
26163   return jresult;
26164 }
26165
26166
26167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26168   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26169
26170   arg1 = (Dali::Shader *)jarg1;
26171   {
26172     try {
26173       delete arg1;
26174     } catch (std::out_of_range& e) {
26175       {
26176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26177       };
26178     } catch (std::exception& e) {
26179       {
26180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26181       };
26182     } catch (Dali::DaliException e) {
26183       {
26184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26185       };
26186     } catch (...) {
26187       {
26188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26189       };
26190     }
26191   }
26192
26193 }
26194
26195
26196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26197   void * jresult ;
26198   Dali::Shader *arg1 = 0 ;
26199   Dali::Shader *result = 0 ;
26200
26201   arg1 = (Dali::Shader *)jarg1;
26202   if (!arg1) {
26203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26204     return 0;
26205   }
26206   {
26207     try {
26208       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26209     } catch (std::out_of_range& e) {
26210       {
26211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26212       };
26213     } catch (std::exception& e) {
26214       {
26215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26216       };
26217     } catch (Dali::DaliException e) {
26218       {
26219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26220       };
26221     } catch (...) {
26222       {
26223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26224       };
26225     }
26226   }
26227
26228   jresult = (void *)result;
26229   return jresult;
26230 }
26231
26232
26233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26234   void * jresult ;
26235   Dali::BaseHandle arg1 ;
26236   Dali::BaseHandle *argp1 ;
26237   Dali::Shader result;
26238
26239   argp1 = (Dali::BaseHandle *)jarg1;
26240   if (!argp1) {
26241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26242     return 0;
26243   }
26244   arg1 = *argp1;
26245   {
26246     try {
26247       result = Dali::Shader::DownCast(arg1);
26248     } catch (std::out_of_range& e) {
26249       {
26250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26251       };
26252     } catch (std::exception& e) {
26253       {
26254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26255       };
26256     } catch (Dali::DaliException e) {
26257       {
26258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26259       };
26260     } catch (...) {
26261       {
26262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26263       };
26264     }
26265   }
26266
26267   jresult = new Dali::Shader((const Dali::Shader &)result);
26268   return jresult;
26269 }
26270
26271
26272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26273   void * jresult ;
26274   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26275   Dali::Shader *arg2 = 0 ;
26276   Dali::Shader *result = 0 ;
26277
26278   arg1 = (Dali::Shader *)jarg1;
26279   arg2 = (Dali::Shader *)jarg2;
26280   if (!arg2) {
26281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26282     return 0;
26283   }
26284   {
26285     try {
26286       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26287     } catch (std::out_of_range& e) {
26288       {
26289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26290       };
26291     } catch (std::exception& e) {
26292       {
26293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26294       };
26295     } catch (Dali::DaliException e) {
26296       {
26297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26298       };
26299     } catch (...) {
26300       {
26301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26302       };
26303     }
26304   }
26305
26306   jresult = (void *)result;
26307   return jresult;
26308 }
26309
26310
26311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26312   int jresult ;
26313   int result;
26314
26315   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26316   jresult = (int)result;
26317   return jresult;
26318 }
26319
26320
26321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26322   int jresult ;
26323   int result;
26324
26325   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26326   jresult = (int)result;
26327   return jresult;
26328 }
26329
26330
26331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26332   int jresult ;
26333   int result;
26334
26335   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26336   jresult = (int)result;
26337   return jresult;
26338 }
26339
26340
26341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26342   int jresult ;
26343   int result;
26344
26345   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26346   jresult = (int)result;
26347   return jresult;
26348 }
26349
26350
26351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26352   int jresult ;
26353   int result;
26354
26355   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26356   jresult = (int)result;
26357   return jresult;
26358 }
26359
26360
26361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26362   int jresult ;
26363   int result;
26364
26365   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26366   jresult = (int)result;
26367   return jresult;
26368 }
26369
26370
26371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26372   int jresult ;
26373   int result;
26374
26375   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26376   jresult = (int)result;
26377   return jresult;
26378 }
26379
26380
26381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26382   int jresult ;
26383   int result;
26384
26385   result = (int)Dali::Renderer::Property::BLEND_MODE;
26386   jresult = (int)result;
26387   return jresult;
26388 }
26389
26390
26391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26392   int jresult ;
26393   int result;
26394
26395   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26396   jresult = (int)result;
26397   return jresult;
26398 }
26399
26400
26401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26402   int jresult ;
26403   int result;
26404
26405   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26406   jresult = (int)result;
26407   return jresult;
26408 }
26409
26410
26411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26412   int jresult ;
26413   int result;
26414
26415   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26416   jresult = (int)result;
26417   return jresult;
26418 }
26419
26420
26421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26422   int jresult ;
26423   int result;
26424
26425   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26426   jresult = (int)result;
26427   return jresult;
26428 }
26429
26430
26431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26432   int jresult ;
26433   int result;
26434
26435   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26436   jresult = (int)result;
26437   return jresult;
26438 }
26439
26440
26441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26442   int jresult ;
26443   int result;
26444
26445   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26446   jresult = (int)result;
26447   return jresult;
26448 }
26449
26450
26451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26452   int jresult ;
26453   int result;
26454
26455   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26456   jresult = (int)result;
26457   return jresult;
26458 }
26459
26460
26461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26462   int jresult ;
26463   int result;
26464
26465   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26466   jresult = (int)result;
26467   return jresult;
26468 }
26469
26470
26471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26472   int jresult ;
26473   int result;
26474
26475   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26476   jresult = (int)result;
26477   return jresult;
26478 }
26479
26480
26481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26482   int jresult ;
26483   int result;
26484
26485   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26486   jresult = (int)result;
26487   return jresult;
26488 }
26489
26490
26491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26492   int jresult ;
26493   int result;
26494
26495   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26496   jresult = (int)result;
26497   return jresult;
26498 }
26499
26500
26501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26502   int jresult ;
26503   int result;
26504
26505   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26506   jresult = (int)result;
26507   return jresult;
26508 }
26509
26510
26511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26512   int jresult ;
26513   int result;
26514
26515   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26516   jresult = (int)result;
26517   return jresult;
26518 }
26519
26520
26521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26522   int jresult ;
26523   int result;
26524
26525   result = (int)Dali::Renderer::Property::RENDER_MODE;
26526   jresult = (int)result;
26527   return jresult;
26528 }
26529
26530
26531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26532   int jresult ;
26533   int result;
26534
26535   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26536   jresult = (int)result;
26537   return jresult;
26538 }
26539
26540
26541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26542   int jresult ;
26543   int result;
26544
26545   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26546   jresult = (int)result;
26547   return jresult;
26548 }
26549
26550
26551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26552   int jresult ;
26553   int result;
26554
26555   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26556   jresult = (int)result;
26557   return jresult;
26558 }
26559
26560
26561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26562   int jresult ;
26563   int result;
26564
26565   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26566   jresult = (int)result;
26567   return jresult;
26568 }
26569
26570
26571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26572   int jresult ;
26573   int result;
26574
26575   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26576   jresult = (int)result;
26577   return jresult;
26578 }
26579
26580
26581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26582   int jresult ;
26583   int result;
26584
26585   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26586   jresult = (int)result;
26587   return jresult;
26588 }
26589
26590
26591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26592   int jresult ;
26593   int result;
26594
26595   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26596   jresult = (int)result;
26597   return jresult;
26598 }
26599
26600
26601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26602   void * jresult ;
26603   Dali::Renderer::Property *result = 0 ;
26604
26605   {
26606     try {
26607       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26608     } catch (std::out_of_range& e) {
26609       {
26610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26611       };
26612     } catch (std::exception& e) {
26613       {
26614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26615       };
26616     } catch (Dali::DaliException e) {
26617       {
26618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26619       };
26620     } catch (...) {
26621       {
26622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26623       };
26624     }
26625   }
26626
26627   jresult = (void *)result;
26628   return jresult;
26629 }
26630
26631
26632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26633   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26634
26635   arg1 = (Dali::Renderer::Property *)jarg1;
26636   {
26637     try {
26638       delete arg1;
26639     } catch (std::out_of_range& e) {
26640       {
26641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26642       };
26643     } catch (std::exception& e) {
26644       {
26645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26646       };
26647     } catch (Dali::DaliException e) {
26648       {
26649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26650       };
26651     } catch (...) {
26652       {
26653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26654       };
26655     }
26656   }
26657
26658 }
26659
26660
26661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26662   void * jresult ;
26663   Dali::Geometry *arg1 = 0 ;
26664   Dali::Shader *arg2 = 0 ;
26665   Dali::Renderer result;
26666
26667   arg1 = (Dali::Geometry *)jarg1;
26668   if (!arg1) {
26669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26670     return 0;
26671   }
26672   arg2 = (Dali::Shader *)jarg2;
26673   if (!arg2) {
26674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26675     return 0;
26676   }
26677   {
26678     try {
26679       result = Dali::Renderer::New(*arg1,*arg2);
26680     } catch (std::out_of_range& e) {
26681       {
26682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26683       };
26684     } catch (std::exception& e) {
26685       {
26686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26687       };
26688     } catch (Dali::DaliException e) {
26689       {
26690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26691       };
26692     } catch (...) {
26693       {
26694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26695       };
26696     }
26697   }
26698
26699   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26700   return jresult;
26701 }
26702
26703
26704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26705   void * jresult ;
26706   Dali::Renderer *result = 0 ;
26707
26708   {
26709     try {
26710       result = (Dali::Renderer *)new Dali::Renderer();
26711     } catch (std::out_of_range& e) {
26712       {
26713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26714       };
26715     } catch (std::exception& e) {
26716       {
26717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26718       };
26719     } catch (Dali::DaliException e) {
26720       {
26721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26722       };
26723     } catch (...) {
26724       {
26725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26726       };
26727     }
26728   }
26729
26730   jresult = (void *)result;
26731   return jresult;
26732 }
26733
26734
26735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26736   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26737
26738   arg1 = (Dali::Renderer *)jarg1;
26739   {
26740     try {
26741       delete arg1;
26742     } catch (std::out_of_range& e) {
26743       {
26744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26745       };
26746     } catch (std::exception& e) {
26747       {
26748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26749       };
26750     } catch (Dali::DaliException e) {
26751       {
26752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26753       };
26754     } catch (...) {
26755       {
26756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26757       };
26758     }
26759   }
26760
26761 }
26762
26763
26764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26765   void * jresult ;
26766   Dali::Renderer *arg1 = 0 ;
26767   Dali::Renderer *result = 0 ;
26768
26769   arg1 = (Dali::Renderer *)jarg1;
26770   if (!arg1) {
26771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26772     return 0;
26773   }
26774   {
26775     try {
26776       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26777     } catch (std::out_of_range& e) {
26778       {
26779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26780       };
26781     } catch (std::exception& e) {
26782       {
26783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26784       };
26785     } catch (Dali::DaliException e) {
26786       {
26787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26788       };
26789     } catch (...) {
26790       {
26791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26792       };
26793     }
26794   }
26795
26796   jresult = (void *)result;
26797   return jresult;
26798 }
26799
26800
26801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26802   void * jresult ;
26803   Dali::BaseHandle arg1 ;
26804   Dali::BaseHandle *argp1 ;
26805   Dali::Renderer result;
26806
26807   argp1 = (Dali::BaseHandle *)jarg1;
26808   if (!argp1) {
26809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26810     return 0;
26811   }
26812   arg1 = *argp1;
26813   {
26814     try {
26815       result = Dali::Renderer::DownCast(arg1);
26816     } catch (std::out_of_range& e) {
26817       {
26818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26819       };
26820     } catch (std::exception& e) {
26821       {
26822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26823       };
26824     } catch (Dali::DaliException e) {
26825       {
26826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26827       };
26828     } catch (...) {
26829       {
26830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26831       };
26832     }
26833   }
26834
26835   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26836   return jresult;
26837 }
26838
26839
26840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26841   void * jresult ;
26842   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26843   Dali::Renderer *arg2 = 0 ;
26844   Dali::Renderer *result = 0 ;
26845
26846   arg1 = (Dali::Renderer *)jarg1;
26847   arg2 = (Dali::Renderer *)jarg2;
26848   if (!arg2) {
26849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26850     return 0;
26851   }
26852   {
26853     try {
26854       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26855     } catch (std::out_of_range& e) {
26856       {
26857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26858       };
26859     } catch (std::exception& e) {
26860       {
26861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26862       };
26863     } catch (Dali::DaliException e) {
26864       {
26865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26866       };
26867     } catch (...) {
26868       {
26869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26870       };
26871     }
26872   }
26873
26874   jresult = (void *)result;
26875   return jresult;
26876 }
26877
26878
26879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26880   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26881   Dali::Geometry *arg2 = 0 ;
26882
26883   arg1 = (Dali::Renderer *)jarg1;
26884   arg2 = (Dali::Geometry *)jarg2;
26885   if (!arg2) {
26886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26887     return ;
26888   }
26889   {
26890     try {
26891       (arg1)->SetGeometry(*arg2);
26892     } catch (std::out_of_range& e) {
26893       {
26894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26895       };
26896     } catch (std::exception& e) {
26897       {
26898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26899       };
26900     } catch (Dali::DaliException e) {
26901       {
26902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26903       };
26904     } catch (...) {
26905       {
26906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26907       };
26908     }
26909   }
26910
26911 }
26912
26913
26914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26915   void * jresult ;
26916   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26917   Dali::Geometry result;
26918
26919   arg1 = (Dali::Renderer *)jarg1;
26920   {
26921     try {
26922       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26923     } catch (std::out_of_range& e) {
26924       {
26925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26926       };
26927     } catch (std::exception& e) {
26928       {
26929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26930       };
26931     } catch (Dali::DaliException e) {
26932       {
26933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26934       };
26935     } catch (...) {
26936       {
26937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26938       };
26939     }
26940   }
26941
26942   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26943   return jresult;
26944 }
26945
26946
26947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26948   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26949   int arg2 ;
26950   int arg3 ;
26951
26952   arg1 = (Dali::Renderer *)jarg1;
26953   arg2 = (int)jarg2;
26954   arg3 = (int)jarg3;
26955   {
26956     try {
26957       (arg1)->SetIndexRange(arg2,arg3);
26958     } catch (std::out_of_range& e) {
26959       {
26960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26961       };
26962     } catch (std::exception& e) {
26963       {
26964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26965       };
26966     } catch (Dali::DaliException e) {
26967       {
26968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26969       };
26970     } catch (...) {
26971       {
26972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26973       };
26974     }
26975   }
26976
26977 }
26978
26979
26980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26981   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26982   Dali::TextureSet *arg2 = 0 ;
26983
26984   arg1 = (Dali::Renderer *)jarg1;
26985   arg2 = (Dali::TextureSet *)jarg2;
26986   if (!arg2) {
26987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26988     return ;
26989   }
26990   {
26991     try {
26992       (arg1)->SetTextures(*arg2);
26993     } catch (std::out_of_range& e) {
26994       {
26995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26996       };
26997     } catch (std::exception& e) {
26998       {
26999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27000       };
27001     } catch (Dali::DaliException e) {
27002       {
27003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27004       };
27005     } catch (...) {
27006       {
27007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27008       };
27009     }
27010   }
27011
27012 }
27013
27014
27015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27016   void * jresult ;
27017   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27018   Dali::TextureSet result;
27019
27020   arg1 = (Dali::Renderer *)jarg1;
27021   {
27022     try {
27023       result = ((Dali::Renderer const *)arg1)->GetTextures();
27024     } catch (std::out_of_range& e) {
27025       {
27026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27027       };
27028     } catch (std::exception& e) {
27029       {
27030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27031       };
27032     } catch (Dali::DaliException e) {
27033       {
27034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27035       };
27036     } catch (...) {
27037       {
27038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27039       };
27040     }
27041   }
27042
27043   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27044   return jresult;
27045 }
27046
27047
27048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27049   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27050   Dali::Shader *arg2 = 0 ;
27051
27052   arg1 = (Dali::Renderer *)jarg1;
27053   arg2 = (Dali::Shader *)jarg2;
27054   if (!arg2) {
27055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27056     return ;
27057   }
27058   {
27059     try {
27060       (arg1)->SetShader(*arg2);
27061     } catch (std::out_of_range& e) {
27062       {
27063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27064       };
27065     } catch (std::exception& e) {
27066       {
27067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27068       };
27069     } catch (Dali::DaliException e) {
27070       {
27071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27072       };
27073     } catch (...) {
27074       {
27075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27076       };
27077     }
27078   }
27079
27080 }
27081
27082
27083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27084   void * jresult ;
27085   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27086   Dali::Shader result;
27087
27088   arg1 = (Dali::Renderer *)jarg1;
27089   {
27090     try {
27091       result = ((Dali::Renderer const *)arg1)->GetShader();
27092     } catch (std::out_of_range& e) {
27093       {
27094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27095       };
27096     } catch (std::exception& e) {
27097       {
27098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27099       };
27100     } catch (Dali::DaliException e) {
27101       {
27102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27103       };
27104     } catch (...) {
27105       {
27106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27107       };
27108     }
27109   }
27110
27111   jresult = new Dali::Shader((const Dali::Shader &)result);
27112   return jresult;
27113 }
27114
27115
27116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27117   void * jresult ;
27118   Dali::FrameBuffer::Attachment *result = 0 ;
27119
27120   {
27121     try {
27122       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27123     } catch (std::out_of_range& e) {
27124       {
27125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27126       };
27127     } catch (std::exception& e) {
27128       {
27129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27130       };
27131     } catch (Dali::DaliException e) {
27132       {
27133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27134       };
27135     } catch (...) {
27136       {
27137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27138       };
27139     }
27140   }
27141
27142   jresult = (void *)result;
27143   return jresult;
27144 }
27145
27146
27147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27148   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27149
27150   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27151   {
27152     try {
27153       delete arg1;
27154     } catch (std::out_of_range& e) {
27155       {
27156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27157       };
27158     } catch (std::exception& e) {
27159       {
27160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27161       };
27162     } catch (Dali::DaliException e) {
27163       {
27164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27165       };
27166     } catch (...) {
27167       {
27168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27169       };
27170     }
27171   }
27172
27173 }
27174
27175
27176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27177   void * jresult ;
27178   unsigned int arg1 ;
27179   unsigned int arg2 ;
27180   unsigned int arg3 ;
27181   Dali::FrameBuffer result;
27182
27183   arg1 = (unsigned int)jarg1;
27184   arg2 = (unsigned int)jarg2;
27185   arg3 = (unsigned int)jarg3;
27186   {
27187     try {
27188       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
27189     } catch (std::out_of_range& e) {
27190       {
27191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27192       };
27193     } catch (std::exception& e) {
27194       {
27195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27196       };
27197     } catch (Dali::DaliException e) {
27198       {
27199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27200       };
27201     } catch (...) {
27202       {
27203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27204       };
27205     }
27206   }
27207
27208   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27209   return jresult;
27210 }
27211
27212
27213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27214   void * jresult ;
27215   Dali::FrameBuffer *result = 0 ;
27216
27217   {
27218     try {
27219       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27220     } catch (std::out_of_range& e) {
27221       {
27222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27223       };
27224     } catch (std::exception& e) {
27225       {
27226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27227       };
27228     } catch (Dali::DaliException e) {
27229       {
27230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27231       };
27232     } catch (...) {
27233       {
27234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27235       };
27236     }
27237   }
27238
27239   jresult = (void *)result;
27240   return jresult;
27241 }
27242
27243
27244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27245   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27246
27247   arg1 = (Dali::FrameBuffer *)jarg1;
27248   {
27249     try {
27250       delete arg1;
27251     } catch (std::out_of_range& e) {
27252       {
27253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27254       };
27255     } catch (std::exception& e) {
27256       {
27257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27258       };
27259     } catch (Dali::DaliException e) {
27260       {
27261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27262       };
27263     } catch (...) {
27264       {
27265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27266       };
27267     }
27268   }
27269
27270 }
27271
27272
27273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27274   void * jresult ;
27275   Dali::FrameBuffer *arg1 = 0 ;
27276   Dali::FrameBuffer *result = 0 ;
27277
27278   arg1 = (Dali::FrameBuffer *)jarg1;
27279   if (!arg1) {
27280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27281     return 0;
27282   }
27283   {
27284     try {
27285       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27286     } catch (std::out_of_range& e) {
27287       {
27288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27289       };
27290     } catch (std::exception& e) {
27291       {
27292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27293       };
27294     } catch (Dali::DaliException e) {
27295       {
27296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27297       };
27298     } catch (...) {
27299       {
27300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27301       };
27302     }
27303   }
27304
27305   jresult = (void *)result;
27306   return jresult;
27307 }
27308
27309
27310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27311   void * jresult ;
27312   Dali::BaseHandle arg1 ;
27313   Dali::BaseHandle *argp1 ;
27314   Dali::FrameBuffer result;
27315
27316   argp1 = (Dali::BaseHandle *)jarg1;
27317   if (!argp1) {
27318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27319     return 0;
27320   }
27321   arg1 = *argp1;
27322   {
27323     try {
27324       result = Dali::FrameBuffer::DownCast(arg1);
27325     } catch (std::out_of_range& e) {
27326       {
27327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27328       };
27329     } catch (std::exception& e) {
27330       {
27331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27332       };
27333     } catch (Dali::DaliException e) {
27334       {
27335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27336       };
27337     } catch (...) {
27338       {
27339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27340       };
27341     }
27342   }
27343
27344   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27345   return jresult;
27346 }
27347
27348
27349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27350   void * jresult ;
27351   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27352   Dali::FrameBuffer *arg2 = 0 ;
27353   Dali::FrameBuffer *result = 0 ;
27354
27355   arg1 = (Dali::FrameBuffer *)jarg1;
27356   arg2 = (Dali::FrameBuffer *)jarg2;
27357   if (!arg2) {
27358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27359     return 0;
27360   }
27361   {
27362     try {
27363       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27364     } catch (std::out_of_range& e) {
27365       {
27366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27367       };
27368     } catch (std::exception& e) {
27369       {
27370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27371       };
27372     } catch (Dali::DaliException e) {
27373       {
27374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27375       };
27376     } catch (...) {
27377       {
27378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27379       };
27380     }
27381   }
27382
27383   jresult = (void *)result;
27384   return jresult;
27385 }
27386
27387
27388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27389   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27390   Dali::Texture *arg2 = 0 ;
27391
27392   arg1 = (Dali::FrameBuffer *)jarg1;
27393   arg2 = (Dali::Texture *)jarg2;
27394   if (!arg2) {
27395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27396     return ;
27397   }
27398   {
27399     try {
27400       (arg1)->AttachColorTexture(*arg2);
27401     } catch (std::out_of_range& e) {
27402       {
27403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27404       };
27405     } catch (std::exception& e) {
27406       {
27407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27408       };
27409     } catch (Dali::DaliException e) {
27410       {
27411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27412       };
27413     } catch (...) {
27414       {
27415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27416       };
27417     }
27418   }
27419
27420 }
27421
27422
27423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27424   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27425   Dali::Texture *arg2 = 0 ;
27426   unsigned int arg3 ;
27427   unsigned int arg4 ;
27428
27429   arg1 = (Dali::FrameBuffer *)jarg1;
27430   arg2 = (Dali::Texture *)jarg2;
27431   if (!arg2) {
27432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27433     return ;
27434   }
27435   arg3 = (unsigned int)jarg3;
27436   arg4 = (unsigned int)jarg4;
27437   {
27438     try {
27439       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27440     } catch (std::out_of_range& e) {
27441       {
27442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27443       };
27444     } catch (std::exception& e) {
27445       {
27446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27447       };
27448     } catch (Dali::DaliException e) {
27449       {
27450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27451       };
27452     } catch (...) {
27453       {
27454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27455       };
27456     }
27457   }
27458
27459 }
27460
27461
27462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27463   void * jresult ;
27464   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27465   Dali::Texture result;
27466
27467   arg1 = (Dali::FrameBuffer *)jarg1;
27468   {
27469     try {
27470       result = (arg1)->GetColorTexture();
27471     } catch (std::out_of_range& e) {
27472       {
27473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27474       };
27475     } catch (std::exception& e) {
27476       {
27477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27478       };
27479     } catch (Dali::DaliException e) {
27480       {
27481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27482       };
27483     } catch (...) {
27484       {
27485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27486       };
27487     }
27488   }
27489
27490   jresult = new Dali::Texture((const Dali::Texture &)result);
27491   return jresult;
27492 }
27493
27494
27495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27496   void * jresult ;
27497   Dali::RenderTaskList *result = 0 ;
27498
27499   {
27500     try {
27501       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27502     } catch (std::out_of_range& e) {
27503       {
27504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27505       };
27506     } catch (std::exception& e) {
27507       {
27508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27509       };
27510     } catch (Dali::DaliException e) {
27511       {
27512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27513       };
27514     } catch (...) {
27515       {
27516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27517       };
27518     }
27519   }
27520
27521   jresult = (void *)result;
27522   return jresult;
27523 }
27524
27525
27526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27527   void * jresult ;
27528   Dali::BaseHandle arg1 ;
27529   Dali::BaseHandle *argp1 ;
27530   Dali::RenderTaskList result;
27531
27532   argp1 = (Dali::BaseHandle *)jarg1;
27533   if (!argp1) {
27534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27535     return 0;
27536   }
27537   arg1 = *argp1;
27538   {
27539     try {
27540       result = Dali::RenderTaskList::DownCast(arg1);
27541     } catch (std::out_of_range& e) {
27542       {
27543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27544       };
27545     } catch (std::exception& e) {
27546       {
27547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27548       };
27549     } catch (Dali::DaliException e) {
27550       {
27551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27552       };
27553     } catch (...) {
27554       {
27555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27556       };
27557     }
27558   }
27559
27560   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27561   return jresult;
27562 }
27563
27564
27565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27566   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27567
27568   arg1 = (Dali::RenderTaskList *)jarg1;
27569   {
27570     try {
27571       delete arg1;
27572     } catch (std::out_of_range& e) {
27573       {
27574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27575       };
27576     } catch (std::exception& e) {
27577       {
27578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27579       };
27580     } catch (Dali::DaliException e) {
27581       {
27582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27583       };
27584     } catch (...) {
27585       {
27586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27587       };
27588     }
27589   }
27590
27591 }
27592
27593
27594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27595   void * jresult ;
27596   Dali::RenderTaskList *arg1 = 0 ;
27597   Dali::RenderTaskList *result = 0 ;
27598
27599   arg1 = (Dali::RenderTaskList *)jarg1;
27600   if (!arg1) {
27601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27602     return 0;
27603   }
27604   {
27605     try {
27606       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27607     } catch (std::out_of_range& e) {
27608       {
27609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27610       };
27611     } catch (std::exception& e) {
27612       {
27613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27614       };
27615     } catch (Dali::DaliException e) {
27616       {
27617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27618       };
27619     } catch (...) {
27620       {
27621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27622       };
27623     }
27624   }
27625
27626   jresult = (void *)result;
27627   return jresult;
27628 }
27629
27630
27631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27632   void * jresult ;
27633   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27634   Dali::RenderTaskList *arg2 = 0 ;
27635   Dali::RenderTaskList *result = 0 ;
27636
27637   arg1 = (Dali::RenderTaskList *)jarg1;
27638   arg2 = (Dali::RenderTaskList *)jarg2;
27639   if (!arg2) {
27640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27641     return 0;
27642   }
27643   {
27644     try {
27645       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27646     } catch (std::out_of_range& e) {
27647       {
27648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27649       };
27650     } catch (std::exception& e) {
27651       {
27652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27653       };
27654     } catch (Dali::DaliException e) {
27655       {
27656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27657       };
27658     } catch (...) {
27659       {
27660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27661       };
27662     }
27663   }
27664
27665   jresult = (void *)result;
27666   return jresult;
27667 }
27668
27669
27670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27671   void * jresult ;
27672   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27673   Dali::RenderTask result;
27674
27675   arg1 = (Dali::RenderTaskList *)jarg1;
27676   {
27677     try {
27678       result = (arg1)->CreateTask();
27679     } catch (std::out_of_range& e) {
27680       {
27681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27682       };
27683     } catch (std::exception& e) {
27684       {
27685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27686       };
27687     } catch (Dali::DaliException e) {
27688       {
27689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27690       };
27691     } catch (...) {
27692       {
27693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27694       };
27695     }
27696   }
27697
27698   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27699   return jresult;
27700 }
27701
27702
27703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27704   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27705   Dali::RenderTask arg2 ;
27706   Dali::RenderTask *argp2 ;
27707
27708   arg1 = (Dali::RenderTaskList *)jarg1;
27709   argp2 = (Dali::RenderTask *)jarg2;
27710   if (!argp2) {
27711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27712     return ;
27713   }
27714   arg2 = *argp2;
27715   {
27716     try {
27717       (arg1)->RemoveTask(arg2);
27718     } catch (std::out_of_range& e) {
27719       {
27720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27721       };
27722     } catch (std::exception& e) {
27723       {
27724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27725       };
27726     } catch (Dali::DaliException e) {
27727       {
27728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27729       };
27730     } catch (...) {
27731       {
27732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27733       };
27734     }
27735   }
27736
27737 }
27738
27739
27740 //// ===============================================end part 1 =================
27741
27742 //// ========================= part 2 ===============================
27743
27744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27745   unsigned int jresult ;
27746   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27747   unsigned int result;
27748
27749   arg1 = (Dali::RenderTaskList *)jarg1;
27750   {
27751     try {
27752       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27753     } catch (std::out_of_range& e) {
27754       {
27755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27756       };
27757     } catch (std::exception& e) {
27758       {
27759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27760       };
27761     } catch (Dali::DaliException e) {
27762       {
27763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27764       };
27765     } catch (...) {
27766       {
27767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27768       };
27769     }
27770   }
27771
27772   jresult = result;
27773   return jresult;
27774 }
27775
27776
27777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27778   void * jresult ;
27779   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27780   unsigned int arg2 ;
27781   Dali::RenderTask result;
27782
27783   arg1 = (Dali::RenderTaskList *)jarg1;
27784   arg2 = (unsigned int)jarg2;
27785   {
27786     try {
27787       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27788     } catch (std::out_of_range& e) {
27789       {
27790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27791       };
27792     } catch (std::exception& e) {
27793       {
27794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27795       };
27796     } catch (Dali::DaliException e) {
27797       {
27798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27799       };
27800     } catch (...) {
27801       {
27802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27803       };
27804     }
27805   }
27806
27807   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27808   return jresult;
27809 }
27810
27811
27812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27813   int jresult ;
27814   int result;
27815
27816   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27817   jresult = (int)result;
27818   return jresult;
27819 }
27820
27821
27822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27823   int jresult ;
27824   int result;
27825
27826   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27827   jresult = (int)result;
27828   return jresult;
27829 }
27830
27831
27832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27833   int jresult ;
27834   int result;
27835
27836   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27837   jresult = (int)result;
27838   return jresult;
27839 }
27840
27841
27842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27843   int jresult ;
27844   int result;
27845
27846   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27847   jresult = (int)result;
27848   return jresult;
27849 }
27850
27851
27852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27853   void * jresult ;
27854   Dali::RenderTask::Property *result = 0 ;
27855
27856   {
27857     try {
27858       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27859     } catch (std::out_of_range& e) {
27860       {
27861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27862       };
27863     } catch (std::exception& e) {
27864       {
27865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27866       };
27867     } catch (Dali::DaliException e) {
27868       {
27869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27870       };
27871     } catch (...) {
27872       {
27873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27874       };
27875     }
27876   }
27877
27878   jresult = (void *)result;
27879   return jresult;
27880 }
27881
27882
27883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27884   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27885
27886   arg1 = (Dali::RenderTask::Property *)jarg1;
27887   {
27888     try {
27889       delete arg1;
27890     } catch (std::out_of_range& e) {
27891       {
27892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27893       };
27894     } catch (std::exception& e) {
27895       {
27896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27897       };
27898     } catch (Dali::DaliException e) {
27899       {
27900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27901       };
27902     } catch (...) {
27903       {
27904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27905       };
27906     }
27907   }
27908
27909 }
27910
27911
27912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27913   void * jresult ;
27914   bool (*result)(Dali::Vector2 &) = 0 ;
27915
27916   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27917   jresult = (void *)result;
27918   return jresult;
27919 }
27920
27921
27922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27923   void * jresult ;
27924   bool (*result)(Dali::Vector2 &) = 0 ;
27925
27926   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27927   jresult = (void *)result;
27928   return jresult;
27929 }
27930
27931
27932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27933   unsigned int jresult ;
27934   bool result;
27935
27936   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27937   jresult = result;
27938   return jresult;
27939 }
27940
27941
27942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27943   unsigned int jresult ;
27944   bool result;
27945
27946   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27947   jresult = result;
27948   return jresult;
27949 }
27950
27951
27952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27953   void * jresult ;
27954   Dali::Vector4 *result = 0 ;
27955
27956   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27957   jresult = (void *)result;
27958   return jresult;
27959 }
27960
27961
27962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27963   unsigned int jresult ;
27964   bool result;
27965
27966   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27967   jresult = result;
27968   return jresult;
27969 }
27970
27971
27972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27973   unsigned int jresult ;
27974   bool result;
27975
27976   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27977   jresult = result;
27978   return jresult;
27979 }
27980
27981
27982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27983   unsigned int jresult ;
27984   unsigned int result;
27985
27986   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27987   jresult = result;
27988   return jresult;
27989 }
27990
27991
27992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27993   void * jresult ;
27994   Dali::RenderTask *result = 0 ;
27995
27996   {
27997     try {
27998       result = (Dali::RenderTask *)new Dali::RenderTask();
27999     } catch (std::out_of_range& e) {
28000       {
28001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28002       };
28003     } catch (std::exception& e) {
28004       {
28005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28006       };
28007     } catch (Dali::DaliException e) {
28008       {
28009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28010       };
28011     } catch (...) {
28012       {
28013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28014       };
28015     }
28016   }
28017
28018   jresult = (void *)result;
28019   return jresult;
28020 }
28021
28022
28023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28024   void * jresult ;
28025   Dali::BaseHandle arg1 ;
28026   Dali::BaseHandle *argp1 ;
28027   Dali::RenderTask result;
28028
28029   argp1 = (Dali::BaseHandle *)jarg1;
28030   if (!argp1) {
28031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28032     return 0;
28033   }
28034   arg1 = *argp1;
28035   {
28036     try {
28037       result = Dali::RenderTask::DownCast(arg1);
28038     } catch (std::out_of_range& e) {
28039       {
28040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28041       };
28042     } catch (std::exception& e) {
28043       {
28044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28045       };
28046     } catch (Dali::DaliException e) {
28047       {
28048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28049       };
28050     } catch (...) {
28051       {
28052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28053       };
28054     }
28055   }
28056
28057   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28058   return jresult;
28059 }
28060
28061
28062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28063   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28064
28065   arg1 = (Dali::RenderTask *)jarg1;
28066   {
28067     try {
28068       delete arg1;
28069     } catch (std::out_of_range& e) {
28070       {
28071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28072       };
28073     } catch (std::exception& e) {
28074       {
28075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28076       };
28077     } catch (Dali::DaliException e) {
28078       {
28079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28080       };
28081     } catch (...) {
28082       {
28083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28084       };
28085     }
28086   }
28087
28088 }
28089
28090
28091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28092   void * jresult ;
28093   Dali::RenderTask *arg1 = 0 ;
28094   Dali::RenderTask *result = 0 ;
28095
28096   arg1 = (Dali::RenderTask *)jarg1;
28097   if (!arg1) {
28098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28099     return 0;
28100   }
28101   {
28102     try {
28103       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28104     } catch (std::out_of_range& e) {
28105       {
28106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28107       };
28108     } catch (std::exception& e) {
28109       {
28110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28111       };
28112     } catch (Dali::DaliException e) {
28113       {
28114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28115       };
28116     } catch (...) {
28117       {
28118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28119       };
28120     }
28121   }
28122
28123   jresult = (void *)result;
28124   return jresult;
28125 }
28126
28127
28128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28129   void * jresult ;
28130   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28131   Dali::RenderTask *arg2 = 0 ;
28132   Dali::RenderTask *result = 0 ;
28133
28134   arg1 = (Dali::RenderTask *)jarg1;
28135   arg2 = (Dali::RenderTask *)jarg2;
28136   if (!arg2) {
28137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28138     return 0;
28139   }
28140   {
28141     try {
28142       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28143     } catch (std::out_of_range& e) {
28144       {
28145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28146       };
28147     } catch (std::exception& e) {
28148       {
28149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28150       };
28151     } catch (Dali::DaliException e) {
28152       {
28153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28154       };
28155     } catch (...) {
28156       {
28157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28158       };
28159     }
28160   }
28161
28162   jresult = (void *)result;
28163   return jresult;
28164 }
28165
28166
28167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28168   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28169   Dali::Actor arg2 ;
28170   Dali::Actor *argp2 ;
28171
28172   arg1 = (Dali::RenderTask *)jarg1;
28173   argp2 = (Dali::Actor *)jarg2;
28174   if (!argp2) {
28175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28176     return ;
28177   }
28178   arg2 = *argp2;
28179   {
28180     try {
28181       (arg1)->SetSourceActor(arg2);
28182     } catch (std::out_of_range& e) {
28183       {
28184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28185       };
28186     } catch (std::exception& e) {
28187       {
28188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28189       };
28190     } catch (Dali::DaliException e) {
28191       {
28192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28193       };
28194     } catch (...) {
28195       {
28196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28197       };
28198     }
28199   }
28200
28201 }
28202
28203
28204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28205   void * jresult ;
28206   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28207   Dali::Actor result;
28208
28209   arg1 = (Dali::RenderTask *)jarg1;
28210   {
28211     try {
28212       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28213     } catch (std::out_of_range& e) {
28214       {
28215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28216       };
28217     } catch (std::exception& e) {
28218       {
28219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28220       };
28221     } catch (Dali::DaliException e) {
28222       {
28223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28224       };
28225     } catch (...) {
28226       {
28227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28228       };
28229     }
28230   }
28231
28232   jresult = new Dali::Actor((const Dali::Actor &)result);
28233   return jresult;
28234 }
28235
28236
28237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28238   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28239   bool arg2 ;
28240
28241   arg1 = (Dali::RenderTask *)jarg1;
28242   arg2 = jarg2 ? true : false;
28243   {
28244     try {
28245       (arg1)->SetExclusive(arg2);
28246     } catch (std::out_of_range& e) {
28247       {
28248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28249       };
28250     } catch (std::exception& e) {
28251       {
28252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28253       };
28254     } catch (Dali::DaliException e) {
28255       {
28256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28257       };
28258     } catch (...) {
28259       {
28260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28261       };
28262     }
28263   }
28264
28265 }
28266
28267
28268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28269   unsigned int jresult ;
28270   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28271   bool result;
28272
28273   arg1 = (Dali::RenderTask *)jarg1;
28274   {
28275     try {
28276       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28277     } catch (std::out_of_range& e) {
28278       {
28279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28280       };
28281     } catch (std::exception& e) {
28282       {
28283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28284       };
28285     } catch (Dali::DaliException e) {
28286       {
28287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28288       };
28289     } catch (...) {
28290       {
28291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28292       };
28293     }
28294   }
28295
28296   jresult = result;
28297   return jresult;
28298 }
28299
28300
28301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28302   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28303   bool arg2 ;
28304
28305   arg1 = (Dali::RenderTask *)jarg1;
28306   arg2 = jarg2 ? true : false;
28307   {
28308     try {
28309       (arg1)->SetInputEnabled(arg2);
28310     } catch (std::out_of_range& e) {
28311       {
28312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28313       };
28314     } catch (std::exception& e) {
28315       {
28316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28317       };
28318     } catch (Dali::DaliException e) {
28319       {
28320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28321       };
28322     } catch (...) {
28323       {
28324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28325       };
28326     }
28327   }
28328
28329 }
28330
28331
28332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28333   unsigned int jresult ;
28334   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28335   bool result;
28336
28337   arg1 = (Dali::RenderTask *)jarg1;
28338   {
28339     try {
28340       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28341     } catch (std::out_of_range& e) {
28342       {
28343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28344       };
28345     } catch (std::exception& e) {
28346       {
28347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28348       };
28349     } catch (Dali::DaliException e) {
28350       {
28351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28352       };
28353     } catch (...) {
28354       {
28355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28356       };
28357     }
28358   }
28359
28360   jresult = result;
28361   return jresult;
28362 }
28363
28364
28365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28366   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28367   Dali::CameraActor arg2 ;
28368   Dali::CameraActor *argp2 ;
28369
28370   arg1 = (Dali::RenderTask *)jarg1;
28371   argp2 = (Dali::CameraActor *)jarg2;
28372   if (!argp2) {
28373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28374     return ;
28375   }
28376   arg2 = *argp2;
28377   {
28378     try {
28379       (arg1)->SetCameraActor(arg2);
28380     } catch (std::out_of_range& e) {
28381       {
28382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28383       };
28384     } catch (std::exception& e) {
28385       {
28386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28387       };
28388     } catch (Dali::DaliException e) {
28389       {
28390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28391       };
28392     } catch (...) {
28393       {
28394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28395       };
28396     }
28397   }
28398
28399 }
28400
28401
28402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28403   void * jresult ;
28404   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28405   Dali::CameraActor result;
28406
28407   arg1 = (Dali::RenderTask *)jarg1;
28408   {
28409     try {
28410       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28411     } catch (std::out_of_range& e) {
28412       {
28413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28414       };
28415     } catch (std::exception& e) {
28416       {
28417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28418       };
28419     } catch (Dali::DaliException e) {
28420       {
28421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28422       };
28423     } catch (...) {
28424       {
28425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28426       };
28427     }
28428   }
28429
28430   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28431   return jresult;
28432 }
28433
28434
28435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28436   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28437   Dali::FrameBuffer arg2 ;
28438   Dali::FrameBuffer *argp2 ;
28439
28440   arg1 = (Dali::RenderTask *)jarg1;
28441   argp2 = (Dali::FrameBuffer *)jarg2;
28442   if (!argp2) {
28443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28444     return ;
28445   }
28446   arg2 = *argp2;
28447   {
28448     try {
28449       (arg1)->SetFrameBuffer(arg2);
28450     } catch (std::out_of_range& e) {
28451       {
28452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28453       };
28454     } catch (std::exception& e) {
28455       {
28456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28457       };
28458     } catch (Dali::DaliException e) {
28459       {
28460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28461       };
28462     } catch (...) {
28463       {
28464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28465       };
28466     }
28467   }
28468
28469 }
28470
28471
28472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28473   void * jresult ;
28474   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28475   Dali::FrameBuffer result;
28476
28477   arg1 = (Dali::RenderTask *)jarg1;
28478   {
28479     try {
28480       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28481     } catch (std::out_of_range& e) {
28482       {
28483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28484       };
28485     } catch (std::exception& e) {
28486       {
28487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28488       };
28489     } catch (Dali::DaliException e) {
28490       {
28491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28492       };
28493     } catch (...) {
28494       {
28495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28496       };
28497     }
28498   }
28499
28500   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28501   return jresult;
28502 }
28503
28504
28505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28506   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28507   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28508
28509   arg1 = (Dali::RenderTask *)jarg1;
28510   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28511   {
28512     try {
28513       (arg1)->SetScreenToFrameBufferFunction(arg2);
28514     } catch (std::out_of_range& e) {
28515       {
28516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28517       };
28518     } catch (std::exception& e) {
28519       {
28520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28521       };
28522     } catch (Dali::DaliException e) {
28523       {
28524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28525       };
28526     } catch (...) {
28527       {
28528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28529       };
28530     }
28531   }
28532
28533 }
28534
28535
28536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28537   void * jresult ;
28538   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28539   Dali::RenderTask::ScreenToFrameBufferFunction result;
28540
28541   arg1 = (Dali::RenderTask *)jarg1;
28542   {
28543     try {
28544       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28545     } catch (std::out_of_range& e) {
28546       {
28547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28548       };
28549     } catch (std::exception& e) {
28550       {
28551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28552       };
28553     } catch (Dali::DaliException e) {
28554       {
28555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28556       };
28557     } catch (...) {
28558       {
28559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28560       };
28561     }
28562   }
28563
28564   jresult = (void *)result;
28565   return jresult;
28566 }
28567
28568
28569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28570   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28571   Dali::Actor arg2 ;
28572   Dali::Actor *argp2 ;
28573
28574   arg1 = (Dali::RenderTask *)jarg1;
28575   argp2 = (Dali::Actor *)jarg2;
28576   if (!argp2) {
28577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28578     return ;
28579   }
28580   arg2 = *argp2;
28581   {
28582     try {
28583       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28584     } catch (std::out_of_range& e) {
28585       {
28586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28587       };
28588     } catch (std::exception& e) {
28589       {
28590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28591       };
28592     } catch (Dali::DaliException e) {
28593       {
28594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28595       };
28596     } catch (...) {
28597       {
28598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28599       };
28600     }
28601   }
28602
28603 }
28604
28605
28606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28607   void * jresult ;
28608   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28609   Dali::Actor result;
28610
28611   arg1 = (Dali::RenderTask *)jarg1;
28612   {
28613     try {
28614       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28615     } catch (std::out_of_range& e) {
28616       {
28617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28618       };
28619     } catch (std::exception& e) {
28620       {
28621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28622       };
28623     } catch (Dali::DaliException e) {
28624       {
28625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28626       };
28627     } catch (...) {
28628       {
28629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28630       };
28631     }
28632   }
28633
28634   jresult = new Dali::Actor((const Dali::Actor &)result);
28635   return jresult;
28636 }
28637
28638
28639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28640   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28641   Dali::Vector2 arg2 ;
28642   Dali::Vector2 *argp2 ;
28643
28644   arg1 = (Dali::RenderTask *)jarg1;
28645   argp2 = (Dali::Vector2 *)jarg2;
28646   if (!argp2) {
28647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28648     return ;
28649   }
28650   arg2 = *argp2;
28651   {
28652     try {
28653       (arg1)->SetViewportPosition(arg2);
28654     } catch (std::out_of_range& e) {
28655       {
28656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28657       };
28658     } catch (std::exception& e) {
28659       {
28660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28661       };
28662     } catch (Dali::DaliException e) {
28663       {
28664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28665       };
28666     } catch (...) {
28667       {
28668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28669       };
28670     }
28671   }
28672
28673 }
28674
28675
28676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28677   void * jresult ;
28678   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28679   Dali::Vector2 result;
28680
28681   arg1 = (Dali::RenderTask *)jarg1;
28682   {
28683     try {
28684       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28685     } catch (std::out_of_range& e) {
28686       {
28687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28688       };
28689     } catch (std::exception& e) {
28690       {
28691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28692       };
28693     } catch (Dali::DaliException e) {
28694       {
28695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28696       };
28697     } catch (...) {
28698       {
28699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28700       };
28701     }
28702   }
28703
28704   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28705   return jresult;
28706 }
28707
28708
28709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28710   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28711   Dali::Vector2 arg2 ;
28712   Dali::Vector2 *argp2 ;
28713
28714   arg1 = (Dali::RenderTask *)jarg1;
28715   argp2 = (Dali::Vector2 *)jarg2;
28716   if (!argp2) {
28717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28718     return ;
28719   }
28720   arg2 = *argp2;
28721   {
28722     try {
28723       (arg1)->SetViewportSize(arg2);
28724     } catch (std::out_of_range& e) {
28725       {
28726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28727       };
28728     } catch (std::exception& e) {
28729       {
28730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28731       };
28732     } catch (Dali::DaliException e) {
28733       {
28734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28735       };
28736     } catch (...) {
28737       {
28738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28739       };
28740     }
28741   }
28742
28743 }
28744
28745
28746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28747   void * jresult ;
28748   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28749   Dali::Vector2 result;
28750
28751   arg1 = (Dali::RenderTask *)jarg1;
28752   {
28753     try {
28754       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28755     } catch (std::out_of_range& e) {
28756       {
28757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28758       };
28759     } catch (std::exception& e) {
28760       {
28761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28762       };
28763     } catch (Dali::DaliException e) {
28764       {
28765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28766       };
28767     } catch (...) {
28768       {
28769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28770       };
28771     }
28772   }
28773
28774   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28775   return jresult;
28776 }
28777
28778
28779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28780   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28781   Dali::Viewport arg2 ;
28782   Dali::Viewport *argp2 ;
28783
28784   arg1 = (Dali::RenderTask *)jarg1;
28785   argp2 = (Dali::Viewport *)jarg2;
28786   if (!argp2) {
28787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28788     return ;
28789   }
28790   arg2 = *argp2;
28791   {
28792     try {
28793       (arg1)->SetViewport(arg2);
28794     } catch (std::out_of_range& e) {
28795       {
28796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28797       };
28798     } catch (std::exception& e) {
28799       {
28800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28801       };
28802     } catch (Dali::DaliException e) {
28803       {
28804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28805       };
28806     } catch (...) {
28807       {
28808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28809       };
28810     }
28811   }
28812
28813 }
28814
28815
28816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28817   void * jresult ;
28818   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28819   Dali::Viewport result;
28820
28821   arg1 = (Dali::RenderTask *)jarg1;
28822   {
28823     try {
28824       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28825     } catch (std::out_of_range& e) {
28826       {
28827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28828       };
28829     } catch (std::exception& e) {
28830       {
28831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28832       };
28833     } catch (Dali::DaliException e) {
28834       {
28835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28836       };
28837     } catch (...) {
28838       {
28839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28840       };
28841     }
28842   }
28843
28844   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28845   return jresult;
28846 }
28847
28848
28849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28850   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28851   Dali::Vector4 *arg2 = 0 ;
28852
28853   arg1 = (Dali::RenderTask *)jarg1;
28854   arg2 = (Dali::Vector4 *)jarg2;
28855   if (!arg2) {
28856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28857     return ;
28858   }
28859   {
28860     try {
28861       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28862     } catch (std::out_of_range& e) {
28863       {
28864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28865       };
28866     } catch (std::exception& e) {
28867       {
28868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28869       };
28870     } catch (Dali::DaliException e) {
28871       {
28872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28873       };
28874     } catch (...) {
28875       {
28876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28877       };
28878     }
28879   }
28880
28881 }
28882
28883
28884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28885   void * jresult ;
28886   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28887   Dali::Vector4 result;
28888
28889   arg1 = (Dali::RenderTask *)jarg1;
28890   {
28891     try {
28892       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28893     } catch (std::out_of_range& e) {
28894       {
28895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28896       };
28897     } catch (std::exception& e) {
28898       {
28899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28900       };
28901     } catch (Dali::DaliException e) {
28902       {
28903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28904       };
28905     } catch (...) {
28906       {
28907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28908       };
28909     }
28910   }
28911
28912   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28913   return jresult;
28914 }
28915
28916
28917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28918   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28919   bool arg2 ;
28920
28921   arg1 = (Dali::RenderTask *)jarg1;
28922   arg2 = jarg2 ? true : false;
28923   {
28924     try {
28925       (arg1)->SetClearEnabled(arg2);
28926     } catch (std::out_of_range& e) {
28927       {
28928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28929       };
28930     } catch (std::exception& e) {
28931       {
28932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28933       };
28934     } catch (Dali::DaliException e) {
28935       {
28936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28937       };
28938     } catch (...) {
28939       {
28940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28941       };
28942     }
28943   }
28944
28945 }
28946
28947
28948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28949   unsigned int jresult ;
28950   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28951   bool result;
28952
28953   arg1 = (Dali::RenderTask *)jarg1;
28954   {
28955     try {
28956       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28957     } catch (std::out_of_range& e) {
28958       {
28959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28960       };
28961     } catch (std::exception& e) {
28962       {
28963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28964       };
28965     } catch (Dali::DaliException e) {
28966       {
28967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28968       };
28969     } catch (...) {
28970       {
28971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28972       };
28973     }
28974   }
28975
28976   jresult = result;
28977   return jresult;
28978 }
28979
28980
28981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28982   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28983   bool arg2 ;
28984
28985   arg1 = (Dali::RenderTask *)jarg1;
28986   arg2 = jarg2 ? true : false;
28987   {
28988     try {
28989       (arg1)->SetCullMode(arg2);
28990     } catch (std::out_of_range& e) {
28991       {
28992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28993       };
28994     } catch (std::exception& e) {
28995       {
28996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28997       };
28998     } catch (Dali::DaliException e) {
28999       {
29000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29001       };
29002     } catch (...) {
29003       {
29004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29005       };
29006     }
29007   }
29008
29009 }
29010
29011
29012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29013   unsigned int jresult ;
29014   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29015   bool result;
29016
29017   arg1 = (Dali::RenderTask *)jarg1;
29018   {
29019     try {
29020       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29021     } catch (std::out_of_range& e) {
29022       {
29023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29024       };
29025     } catch (std::exception& e) {
29026       {
29027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29028       };
29029     } catch (Dali::DaliException e) {
29030       {
29031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29032       };
29033     } catch (...) {
29034       {
29035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29036       };
29037     }
29038   }
29039
29040   jresult = result;
29041   return jresult;
29042 }
29043
29044
29045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29046   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29047   unsigned int arg2 ;
29048
29049   arg1 = (Dali::RenderTask *)jarg1;
29050   arg2 = (unsigned int)jarg2;
29051   {
29052     try {
29053       (arg1)->SetRefreshRate(arg2);
29054     } catch (std::out_of_range& e) {
29055       {
29056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29057       };
29058     } catch (std::exception& e) {
29059       {
29060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29061       };
29062     } catch (Dali::DaliException e) {
29063       {
29064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29065       };
29066     } catch (...) {
29067       {
29068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29069       };
29070     }
29071   }
29072
29073 }
29074
29075
29076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29077   unsigned int jresult ;
29078   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29079   unsigned int result;
29080
29081   arg1 = (Dali::RenderTask *)jarg1;
29082   {
29083     try {
29084       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29085     } catch (std::out_of_range& e) {
29086       {
29087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29088       };
29089     } catch (std::exception& e) {
29090       {
29091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29092       };
29093     } catch (Dali::DaliException e) {
29094       {
29095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29096       };
29097     } catch (...) {
29098       {
29099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29100       };
29101     }
29102   }
29103
29104   jresult = result;
29105   return jresult;
29106 }
29107
29108
29109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29110   unsigned int jresult ;
29111   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29112   Dali::Vector3 *arg2 = 0 ;
29113   float *arg3 = 0 ;
29114   float *arg4 = 0 ;
29115   bool result;
29116
29117   arg1 = (Dali::RenderTask *)jarg1;
29118   arg2 = (Dali::Vector3 *)jarg2;
29119   if (!arg2) {
29120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29121     return 0;
29122   }
29123   arg3 = (float *)jarg3;
29124   arg4 = (float *)jarg4;
29125   {
29126     try {
29127       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29128     } catch (std::out_of_range& e) {
29129       {
29130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29131       };
29132     } catch (std::exception& e) {
29133       {
29134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29135       };
29136     } catch (Dali::DaliException e) {
29137       {
29138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29139       };
29140     } catch (...) {
29141       {
29142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29143       };
29144     }
29145   }
29146
29147   jresult = result;
29148   return jresult;
29149 }
29150
29151
29152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29153   unsigned int jresult ;
29154   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29155   Dali::Actor arg2 ;
29156   float arg3 ;
29157   float arg4 ;
29158   float *arg5 = 0 ;
29159   float *arg6 = 0 ;
29160   Dali::Actor *argp2 ;
29161   bool result;
29162
29163   arg1 = (Dali::RenderTask *)jarg1;
29164   argp2 = (Dali::Actor *)jarg2;
29165   if (!argp2) {
29166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29167     return 0;
29168   }
29169   arg2 = *argp2;
29170   arg3 = (float)jarg3;
29171   arg4 = (float)jarg4;
29172   arg5 = (float *)jarg5;
29173   arg6 = (float *)jarg6;
29174   {
29175     try {
29176       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29177     } catch (std::out_of_range& e) {
29178       {
29179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29180       };
29181     } catch (std::exception& e) {
29182       {
29183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29184       };
29185     } catch (Dali::DaliException e) {
29186       {
29187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29188       };
29189     } catch (...) {
29190       {
29191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29192       };
29193     }
29194   }
29195
29196   jresult = result;
29197   return jresult;
29198 }
29199
29200
29201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29202   void * jresult ;
29203   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29204   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29205
29206   arg1 = (Dali::RenderTask *)jarg1;
29207   {
29208     try {
29209       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29210     } catch (std::out_of_range& e) {
29211       {
29212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29213       };
29214     } catch (std::exception& e) {
29215       {
29216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29217       };
29218     } catch (Dali::DaliException e) {
29219       {
29220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29221       };
29222     } catch (...) {
29223       {
29224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29225       };
29226     }
29227   }
29228
29229   jresult = (void *)result;
29230   return jresult;
29231 }
29232
29233
29234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29235   void * jresult ;
29236   int arg1 ;
29237   Dali::TouchPoint::State arg2 ;
29238   float arg3 ;
29239   float arg4 ;
29240   Dali::TouchPoint *result = 0 ;
29241
29242   arg1 = (int)jarg1;
29243   arg2 = (Dali::TouchPoint::State)jarg2;
29244   arg3 = (float)jarg3;
29245   arg4 = (float)jarg4;
29246   {
29247     try {
29248       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29249     } catch (std::out_of_range& e) {
29250       {
29251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29252       };
29253     } catch (std::exception& e) {
29254       {
29255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29256       };
29257     } catch (Dali::DaliException e) {
29258       {
29259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29260       };
29261     } catch (...) {
29262       {
29263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29264       };
29265     }
29266   }
29267
29268   jresult = (void *)result;
29269   return jresult;
29270 }
29271
29272
29273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29274   void * jresult ;
29275   int arg1 ;
29276   Dali::TouchPoint::State arg2 ;
29277   float arg3 ;
29278   float arg4 ;
29279   float arg5 ;
29280   float arg6 ;
29281   Dali::TouchPoint *result = 0 ;
29282
29283   arg1 = (int)jarg1;
29284   arg2 = (Dali::TouchPoint::State)jarg2;
29285   arg3 = (float)jarg3;
29286   arg4 = (float)jarg4;
29287   arg5 = (float)jarg5;
29288   arg6 = (float)jarg6;
29289   {
29290     try {
29291       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29292     } catch (std::out_of_range& e) {
29293       {
29294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29295       };
29296     } catch (std::exception& e) {
29297       {
29298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29299       };
29300     } catch (Dali::DaliException e) {
29301       {
29302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29303       };
29304     } catch (...) {
29305       {
29306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29307       };
29308     }
29309   }
29310
29311   jresult = (void *)result;
29312   return jresult;
29313 }
29314
29315
29316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29317   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29318
29319   arg1 = (Dali::TouchPoint *)jarg1;
29320   {
29321     try {
29322       delete arg1;
29323     } catch (std::out_of_range& e) {
29324       {
29325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29326       };
29327     } catch (std::exception& e) {
29328       {
29329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29330       };
29331     } catch (Dali::DaliException e) {
29332       {
29333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29334       };
29335     } catch (...) {
29336       {
29337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29338       };
29339     }
29340   }
29341
29342 }
29343
29344
29345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29346   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29347   int arg2 ;
29348
29349   arg1 = (Dali::TouchPoint *)jarg1;
29350   arg2 = (int)jarg2;
29351   if (arg1) (arg1)->deviceId = arg2;
29352 }
29353
29354
29355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29356   int jresult ;
29357   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29358   int result;
29359
29360   arg1 = (Dali::TouchPoint *)jarg1;
29361   result = (int) ((arg1)->deviceId);
29362   jresult = result;
29363   return jresult;
29364 }
29365
29366
29367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29368   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29369   Dali::TouchPoint::State arg2 ;
29370
29371   arg1 = (Dali::TouchPoint *)jarg1;
29372   arg2 = (Dali::TouchPoint::State)jarg2;
29373   if (arg1) (arg1)->state = arg2;
29374 }
29375
29376
29377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29378   int jresult ;
29379   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29380   Dali::TouchPoint::State result;
29381
29382   arg1 = (Dali::TouchPoint *)jarg1;
29383   result = (Dali::TouchPoint::State) ((arg1)->state);
29384   jresult = (int)result;
29385   return jresult;
29386 }
29387
29388
29389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29390   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29391   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29392
29393   arg1 = (Dali::TouchPoint *)jarg1;
29394   arg2 = (Dali::Actor *)jarg2;
29395   if (arg1) (arg1)->hitActor = *arg2;
29396 }
29397
29398
29399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29400   void * jresult ;
29401   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29402   Dali::Actor *result = 0 ;
29403
29404   arg1 = (Dali::TouchPoint *)jarg1;
29405   result = (Dali::Actor *)& ((arg1)->hitActor);
29406   jresult = (void *)result;
29407   return jresult;
29408 }
29409
29410
29411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29412   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29413   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29414
29415   arg1 = (Dali::TouchPoint *)jarg1;
29416   arg2 = (Dali::Vector2 *)jarg2;
29417   if (arg1) (arg1)->local = *arg2;
29418 }
29419
29420
29421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29422   void * jresult ;
29423   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29424   Dali::Vector2 *result = 0 ;
29425
29426   arg1 = (Dali::TouchPoint *)jarg1;
29427   result = (Dali::Vector2 *)& ((arg1)->local);
29428   jresult = (void *)result;
29429   return jresult;
29430 }
29431
29432
29433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29434   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29435   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29436
29437   arg1 = (Dali::TouchPoint *)jarg1;
29438   arg2 = (Dali::Vector2 *)jarg2;
29439   if (arg1) (arg1)->screen = *arg2;
29440 }
29441
29442
29443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29444   void * jresult ;
29445   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29446   Dali::Vector2 *result = 0 ;
29447
29448   arg1 = (Dali::TouchPoint *)jarg1;
29449   result = (Dali::Vector2 *)& ((arg1)->screen);
29450   jresult = (void *)result;
29451   return jresult;
29452 }
29453
29454
29455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29456   void * jresult ;
29457   Dali::TouchData *result = 0 ;
29458
29459   {
29460     try {
29461       result = (Dali::TouchData *)new Dali::TouchData();
29462     } catch (std::out_of_range& e) {
29463       {
29464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29465       };
29466     } catch (std::exception& e) {
29467       {
29468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29469       };
29470     } catch (Dali::DaliException e) {
29471       {
29472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29473       };
29474     } catch (...) {
29475       {
29476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29477       };
29478     }
29479   }
29480
29481   jresult = (void *)result;
29482   return jresult;
29483 }
29484
29485
29486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29487   void * jresult ;
29488   Dali::TouchData *arg1 = 0 ;
29489   Dali::TouchData *result = 0 ;
29490
29491   arg1 = (Dali::TouchData *)jarg1;
29492   if (!arg1) {
29493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29494     return 0;
29495   }
29496   {
29497     try {
29498       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29499     } catch (std::out_of_range& e) {
29500       {
29501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29502       };
29503     } catch (std::exception& e) {
29504       {
29505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29506       };
29507     } catch (Dali::DaliException e) {
29508       {
29509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29510       };
29511     } catch (...) {
29512       {
29513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29514       };
29515     }
29516   }
29517
29518   jresult = (void *)result;
29519   return jresult;
29520 }
29521
29522
29523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29524   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29525
29526   arg1 = (Dali::TouchData *)jarg1;
29527   {
29528     try {
29529       delete arg1;
29530     } catch (std::out_of_range& e) {
29531       {
29532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29533       };
29534     } catch (std::exception& e) {
29535       {
29536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29537       };
29538     } catch (Dali::DaliException e) {
29539       {
29540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29541       };
29542     } catch (...) {
29543       {
29544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29545       };
29546     }
29547   }
29548
29549 }
29550
29551
29552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29553   void * jresult ;
29554   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29555   Dali::TouchData *arg2 = 0 ;
29556   Dali::TouchData *result = 0 ;
29557
29558   arg1 = (Dali::TouchData *)jarg1;
29559   arg2 = (Dali::TouchData *)jarg2;
29560   if (!arg2) {
29561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29562     return 0;
29563   }
29564   {
29565     try {
29566       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29567     } catch (std::out_of_range& e) {
29568       {
29569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29570       };
29571     } catch (std::exception& e) {
29572       {
29573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29574       };
29575     } catch (Dali::DaliException e) {
29576       {
29577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29578       };
29579     } catch (...) {
29580       {
29581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29582       };
29583     }
29584   }
29585
29586   jresult = (void *)result;
29587   return jresult;
29588 }
29589
29590
29591 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29592   unsigned long jresult ;
29593   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29594   unsigned long result;
29595
29596   arg1 = (Dali::TouchData *)jarg1;
29597   {
29598     try {
29599       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29600     } catch (std::out_of_range& e) {
29601       {
29602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29603       };
29604     } catch (std::exception& e) {
29605       {
29606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29607       };
29608     } catch (Dali::DaliException e) {
29609       {
29610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29611       };
29612     } catch (...) {
29613       {
29614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29615       };
29616     }
29617   }
29618
29619   jresult = (unsigned long)result;
29620   return jresult;
29621 }
29622
29623
29624 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29625   unsigned long jresult ;
29626   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29627   std::size_t result;
29628
29629   arg1 = (Dali::TouchData *)jarg1;
29630   {
29631     try {
29632       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29633     } catch (std::out_of_range& e) {
29634       {
29635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29636       };
29637     } catch (std::exception& e) {
29638       {
29639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29640       };
29641     } catch (Dali::DaliException e) {
29642       {
29643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29644       };
29645     } catch (...) {
29646       {
29647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29648       };
29649     }
29650   }
29651
29652   jresult = (unsigned long)result;
29653   return jresult;
29654 }
29655
29656
29657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29658   int jresult ;
29659   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29660   std::size_t arg2 ;
29661   int32_t result;
29662
29663   arg1 = (Dali::TouchData *)jarg1;
29664   arg2 = (std::size_t)jarg2;
29665   {
29666     try {
29667       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29668     } catch (std::out_of_range& e) {
29669       {
29670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29671       };
29672     } catch (std::exception& e) {
29673       {
29674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29675       };
29676     } catch (Dali::DaliException e) {
29677       {
29678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29679       };
29680     } catch (...) {
29681       {
29682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29683       };
29684     }
29685   }
29686
29687   jresult = result;
29688   return jresult;
29689 }
29690
29691
29692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29693   int jresult ;
29694   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29695   std::size_t arg2 ;
29696   Dali::PointState::Type result;
29697
29698   arg1 = (Dali::TouchData *)jarg1;
29699   arg2 = (std::size_t)jarg2;
29700   {
29701     try {
29702       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29703     } catch (std::out_of_range& e) {
29704       {
29705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29706       };
29707     } catch (std::exception& e) {
29708       {
29709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29710       };
29711     } catch (Dali::DaliException e) {
29712       {
29713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29714       };
29715     } catch (...) {
29716       {
29717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29718       };
29719     }
29720   }
29721
29722   jresult = (int)result;
29723   return jresult;
29724 }
29725
29726
29727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29728   void * jresult ;
29729   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29730   std::size_t arg2 ;
29731   Dali::Actor result;
29732
29733   arg1 = (Dali::TouchData *)jarg1;
29734   arg2 = (std::size_t)jarg2;
29735   {
29736     try {
29737       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29738     } catch (std::out_of_range& e) {
29739       {
29740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29741       };
29742     } catch (std::exception& e) {
29743       {
29744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29745       };
29746     } catch (Dali::DaliException e) {
29747       {
29748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29749       };
29750     } catch (...) {
29751       {
29752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29753       };
29754     }
29755   }
29756
29757   jresult = new Dali::Actor((const Dali::Actor &)result);
29758   return jresult;
29759 }
29760
29761
29762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29763   void * jresult ;
29764   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29765   std::size_t arg2 ;
29766   Dali::Vector2 *result = 0 ;
29767
29768   arg1 = (Dali::TouchData *)jarg1;
29769   arg2 = (std::size_t)jarg2;
29770   {
29771     try {
29772       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
29773     } catch (std::out_of_range& e) {
29774       {
29775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29776       };
29777     } catch (std::exception& e) {
29778       {
29779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29780       };
29781     } catch (Dali::DaliException e) {
29782       {
29783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29784       };
29785     } catch (...) {
29786       {
29787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29788       };
29789     }
29790   }
29791
29792   jresult = (void *)result;
29793   return jresult;
29794 }
29795
29796
29797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29798   void * jresult ;
29799   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29800   std::size_t arg2 ;
29801   Dali::Vector2 *result = 0 ;
29802
29803   arg1 = (Dali::TouchData *)jarg1;
29804   arg2 = (std::size_t)jarg2;
29805   {
29806     try {
29807       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
29808     } catch (std::out_of_range& e) {
29809       {
29810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29811       };
29812     } catch (std::exception& e) {
29813       {
29814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29815       };
29816     } catch (Dali::DaliException e) {
29817       {
29818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29819       };
29820     } catch (...) {
29821       {
29822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29823       };
29824     }
29825   }
29826
29827   jresult = (void *)result;
29828   return jresult;
29829 }
29830
29831
29832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29833   float jresult ;
29834   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29835   std::size_t arg2 ;
29836   float result;
29837
29838   arg1 = (Dali::TouchData *)jarg1;
29839   arg2 = (std::size_t)jarg2;
29840   {
29841     try {
29842       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
29843     } catch (std::out_of_range& e) {
29844       {
29845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29846       };
29847     } catch (std::exception& e) {
29848       {
29849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29850       };
29851     } catch (Dali::DaliException e) {
29852       {
29853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29854       };
29855     } catch (...) {
29856       {
29857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29858       };
29859     }
29860   }
29861
29862   jresult = result;
29863   return jresult;
29864 }
29865
29866
29867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29868   void * jresult ;
29869   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29870   std::size_t arg2 ;
29871   Dali::Vector2 *result = 0 ;
29872
29873   arg1 = (Dali::TouchData *)jarg1;
29874   arg2 = (std::size_t)jarg2;
29875   {
29876     try {
29877       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
29878     } catch (std::out_of_range& e) {
29879       {
29880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29881       };
29882     } catch (std::exception& e) {
29883       {
29884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29885       };
29886     } catch (Dali::DaliException e) {
29887       {
29888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29889       };
29890     } catch (...) {
29891       {
29892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29893       };
29894     }
29895   }
29896
29897   jresult = (void *)result;
29898   return jresult;
29899 }
29900
29901
29902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29903   float jresult ;
29904   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29905   std::size_t arg2 ;
29906   float result;
29907
29908   arg1 = (Dali::TouchData *)jarg1;
29909   arg2 = (std::size_t)jarg2;
29910   {
29911     try {
29912       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
29913     } catch (std::out_of_range& e) {
29914       {
29915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29916       };
29917     } catch (std::exception& e) {
29918       {
29919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29920       };
29921     } catch (Dali::DaliException e) {
29922       {
29923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29924       };
29925     } catch (...) {
29926       {
29927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29928       };
29929     }
29930   }
29931
29932   jresult = result;
29933   return jresult;
29934 }
29935
29936
29937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29938   void * jresult ;
29939   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29940   std::size_t arg2 ;
29941   Dali::Degree result;
29942
29943   arg1 = (Dali::TouchData *)jarg1;
29944   arg2 = (std::size_t)jarg2;
29945   {
29946     try {
29947       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
29948     } catch (std::out_of_range& e) {
29949       {
29950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29951       };
29952     } catch (std::exception& e) {
29953       {
29954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29955       };
29956     } catch (Dali::DaliException e) {
29957       {
29958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29959       };
29960     } catch (...) {
29961       {
29962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29963       };
29964     }
29965   }
29966
29967   jresult = new Dali::Degree((const Dali::Degree &)result);
29968   return jresult;
29969 }
29970
29971
29972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29973   int jresult ;
29974   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29975   std::size_t arg2 ;
29976   Dali::MouseButton::Type result;
29977
29978   arg1 = (Dali::TouchData *)jarg1;
29979   arg2 = (std::size_t)jarg2;
29980   {
29981     try {
29982       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
29983     } catch (std::out_of_range& e) {
29984       {
29985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29986       };
29987     } catch (std::exception& e) {
29988       {
29989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29990       };
29991     } catch (Dali::DaliException e) {
29992       {
29993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29994       };
29995     } catch (...) {
29996       {
29997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29998       };
29999     }
30000   }
30001
30002   jresult = static_cast< int >(result);
30003   return jresult;
30004 }
30005
30006
30007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30008   void * jresult ;
30009   Dali::GestureDetector *result = 0 ;
30010
30011   {
30012     try {
30013       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30014     } catch (std::out_of_range& e) {
30015       {
30016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30017       };
30018     } catch (std::exception& e) {
30019       {
30020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30021       };
30022     } catch (Dali::DaliException e) {
30023       {
30024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30025       };
30026     } catch (...) {
30027       {
30028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30029       };
30030     }
30031   }
30032
30033   jresult = (void *)result;
30034   return jresult;
30035 }
30036
30037
30038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30039   void * jresult ;
30040   Dali::BaseHandle arg1 ;
30041   Dali::BaseHandle *argp1 ;
30042   Dali::GestureDetector result;
30043
30044   argp1 = (Dali::BaseHandle *)jarg1;
30045   if (!argp1) {
30046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30047     return 0;
30048   }
30049   arg1 = *argp1;
30050   {
30051     try {
30052       result = Dali::GestureDetector::DownCast(arg1);
30053     } catch (std::out_of_range& e) {
30054       {
30055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30056       };
30057     } catch (std::exception& e) {
30058       {
30059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30060       };
30061     } catch (Dali::DaliException e) {
30062       {
30063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30064       };
30065     } catch (...) {
30066       {
30067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30068       };
30069     }
30070   }
30071
30072   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30073   return jresult;
30074 }
30075
30076
30077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30078   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30079
30080   arg1 = (Dali::GestureDetector *)jarg1;
30081   {
30082     try {
30083       delete arg1;
30084     } catch (std::out_of_range& e) {
30085       {
30086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30087       };
30088     } catch (std::exception& e) {
30089       {
30090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30091       };
30092     } catch (Dali::DaliException e) {
30093       {
30094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30095       };
30096     } catch (...) {
30097       {
30098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30099       };
30100     }
30101   }
30102
30103 }
30104
30105
30106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30107   void * jresult ;
30108   Dali::GestureDetector *arg1 = 0 ;
30109   Dali::GestureDetector *result = 0 ;
30110
30111   arg1 = (Dali::GestureDetector *)jarg1;
30112   if (!arg1) {
30113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30114     return 0;
30115   }
30116   {
30117     try {
30118       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30119     } catch (std::out_of_range& e) {
30120       {
30121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30122       };
30123     } catch (std::exception& e) {
30124       {
30125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30126       };
30127     } catch (Dali::DaliException e) {
30128       {
30129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30130       };
30131     } catch (...) {
30132       {
30133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30134       };
30135     }
30136   }
30137
30138   jresult = (void *)result;
30139   return jresult;
30140 }
30141
30142
30143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30144   void * jresult ;
30145   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30146   Dali::GestureDetector *arg2 = 0 ;
30147   Dali::GestureDetector *result = 0 ;
30148
30149   arg1 = (Dali::GestureDetector *)jarg1;
30150   arg2 = (Dali::GestureDetector *)jarg2;
30151   if (!arg2) {
30152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30153     return 0;
30154   }
30155   {
30156     try {
30157       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30158     } catch (std::out_of_range& e) {
30159       {
30160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30161       };
30162     } catch (std::exception& e) {
30163       {
30164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30165       };
30166     } catch (Dali::DaliException e) {
30167       {
30168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30169       };
30170     } catch (...) {
30171       {
30172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30173       };
30174     }
30175   }
30176
30177   jresult = (void *)result;
30178   return jresult;
30179 }
30180
30181
30182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30183   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30184   Dali::Actor arg2 ;
30185   Dali::Actor *argp2 ;
30186
30187   arg1 = (Dali::GestureDetector *)jarg1;
30188   argp2 = (Dali::Actor *)jarg2;
30189   if (!argp2) {
30190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30191     return ;
30192   }
30193   arg2 = *argp2;
30194   {
30195     try {
30196       (arg1)->Attach(arg2);
30197     } catch (std::out_of_range& e) {
30198       {
30199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30200       };
30201     } catch (std::exception& e) {
30202       {
30203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30204       };
30205     } catch (Dali::DaliException e) {
30206       {
30207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30208       };
30209     } catch (...) {
30210       {
30211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30212       };
30213     }
30214   }
30215
30216 }
30217
30218
30219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30220   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30221   Dali::Actor arg2 ;
30222   Dali::Actor *argp2 ;
30223
30224   arg1 = (Dali::GestureDetector *)jarg1;
30225   argp2 = (Dali::Actor *)jarg2;
30226   if (!argp2) {
30227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30228     return ;
30229   }
30230   arg2 = *argp2;
30231   {
30232     try {
30233       (arg1)->Detach(arg2);
30234     } catch (std::out_of_range& e) {
30235       {
30236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30237       };
30238     } catch (std::exception& e) {
30239       {
30240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30241       };
30242     } catch (Dali::DaliException e) {
30243       {
30244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30245       };
30246     } catch (...) {
30247       {
30248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30249       };
30250     }
30251   }
30252
30253 }
30254
30255
30256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30257   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30258
30259   arg1 = (Dali::GestureDetector *)jarg1;
30260   {
30261     try {
30262       (arg1)->DetachAll();
30263     } catch (std::out_of_range& e) {
30264       {
30265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30266       };
30267     } catch (std::exception& e) {
30268       {
30269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30270       };
30271     } catch (Dali::DaliException e) {
30272       {
30273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30274       };
30275     } catch (...) {
30276       {
30277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30278       };
30279     }
30280   }
30281
30282 }
30283
30284
30285 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30286   unsigned long jresult ;
30287   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30288   size_t result;
30289
30290   arg1 = (Dali::GestureDetector *)jarg1;
30291   {
30292     try {
30293       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30294     } catch (std::out_of_range& e) {
30295       {
30296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30297       };
30298     } catch (std::exception& e) {
30299       {
30300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30301       };
30302     } catch (Dali::DaliException e) {
30303       {
30304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30305       };
30306     } catch (...) {
30307       {
30308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30309       };
30310     }
30311   }
30312
30313   jresult = (unsigned long)result;
30314   return jresult;
30315 }
30316
30317
30318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30319   void * jresult ;
30320   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30321   size_t arg2 ;
30322   Dali::Actor result;
30323
30324   arg1 = (Dali::GestureDetector *)jarg1;
30325   arg2 = (size_t)jarg2;
30326   {
30327     try {
30328       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30329     } catch (std::out_of_range& e) {
30330       {
30331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30332       };
30333     } catch (std::exception& e) {
30334       {
30335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30336       };
30337     } catch (Dali::DaliException e) {
30338       {
30339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30340       };
30341     } catch (...) {
30342       {
30343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30344       };
30345     }
30346   }
30347
30348   jresult = new Dali::Actor((const Dali::Actor &)result);
30349   return jresult;
30350 }
30351
30352
30353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30354   void * jresult ;
30355   Dali::Gesture *arg1 = 0 ;
30356   Dali::Gesture *result = 0 ;
30357
30358   arg1 = (Dali::Gesture *)jarg1;
30359   if (!arg1) {
30360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30361     return 0;
30362   }
30363   {
30364     try {
30365       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30366     } catch (std::out_of_range& e) {
30367       {
30368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30369       };
30370     } catch (std::exception& e) {
30371       {
30372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30373       };
30374     } catch (Dali::DaliException e) {
30375       {
30376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30377       };
30378     } catch (...) {
30379       {
30380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30381       };
30382     }
30383   }
30384
30385   jresult = (void *)result;
30386   return jresult;
30387 }
30388
30389
30390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30391   void * jresult ;
30392   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30393   Dali::Gesture *arg2 = 0 ;
30394   Dali::Gesture *result = 0 ;
30395
30396   arg1 = (Dali::Gesture *)jarg1;
30397   arg2 = (Dali::Gesture *)jarg2;
30398   if (!arg2) {
30399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30400     return 0;
30401   }
30402   {
30403     try {
30404       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30405     } catch (std::out_of_range& e) {
30406       {
30407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30408       };
30409     } catch (std::exception& e) {
30410       {
30411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30412       };
30413     } catch (Dali::DaliException e) {
30414       {
30415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30416       };
30417     } catch (...) {
30418       {
30419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30420       };
30421     }
30422   }
30423
30424   jresult = (void *)result;
30425   return jresult;
30426 }
30427
30428
30429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30430   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30431
30432   arg1 = (Dali::Gesture *)jarg1;
30433   {
30434     try {
30435       delete arg1;
30436     } catch (std::out_of_range& e) {
30437       {
30438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30439       };
30440     } catch (std::exception& e) {
30441       {
30442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30443       };
30444     } catch (Dali::DaliException e) {
30445       {
30446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30447       };
30448     } catch (...) {
30449       {
30450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30451       };
30452     }
30453   }
30454
30455 }
30456
30457
30458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30459   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30460   Dali::Gesture::Type arg2 ;
30461
30462   arg1 = (Dali::Gesture *)jarg1;
30463   arg2 = (Dali::Gesture::Type)jarg2;
30464   if (arg1) (arg1)->type = arg2;
30465 }
30466
30467
30468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30469   int jresult ;
30470   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30471   Dali::Gesture::Type result;
30472
30473   arg1 = (Dali::Gesture *)jarg1;
30474   result = (Dali::Gesture::Type) ((arg1)->type);
30475   jresult = (int)result;
30476   return jresult;
30477 }
30478
30479
30480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30481   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30482   Dali::Gesture::State arg2 ;
30483
30484   arg1 = (Dali::Gesture *)jarg1;
30485   arg2 = (Dali::Gesture::State)jarg2;
30486   if (arg1) (arg1)->state = arg2;
30487 }
30488
30489
30490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30491   int jresult ;
30492   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30493   Dali::Gesture::State result;
30494
30495   arg1 = (Dali::Gesture *)jarg1;
30496   result = (Dali::Gesture::State) ((arg1)->state);
30497   jresult = (int)result;
30498   return jresult;
30499 }
30500
30501
30502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30503   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30504   unsigned int arg2 ;
30505
30506   arg1 = (Dali::Gesture *)jarg1;
30507   arg2 = (unsigned int)jarg2;
30508   if (arg1) (arg1)->time = arg2;
30509 }
30510
30511
30512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30513   unsigned int jresult ;
30514   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30515   unsigned int result;
30516
30517   arg1 = (Dali::Gesture *)jarg1;
30518   result = (unsigned int) ((arg1)->time);
30519   jresult = result;
30520   return jresult;
30521 }
30522
30523
30524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30525   void * jresult ;
30526   Dali::HoverEvent *result = 0 ;
30527
30528   {
30529     try {
30530       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30531     } catch (std::out_of_range& e) {
30532       {
30533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30534       };
30535     } catch (std::exception& e) {
30536       {
30537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30538       };
30539     } catch (Dali::DaliException e) {
30540       {
30541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30542       };
30543     } catch (...) {
30544       {
30545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30546       };
30547     }
30548   }
30549
30550   jresult = (void *)result;
30551   return jresult;
30552 }
30553
30554
30555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30556   void * jresult ;
30557   unsigned long arg1 ;
30558   Dali::HoverEvent *result = 0 ;
30559
30560   arg1 = (unsigned long)jarg1;
30561   {
30562     try {
30563       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30564     } catch (std::out_of_range& e) {
30565       {
30566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30567       };
30568     } catch (std::exception& e) {
30569       {
30570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30571       };
30572     } catch (Dali::DaliException e) {
30573       {
30574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30575       };
30576     } catch (...) {
30577       {
30578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30579       };
30580     }
30581   }
30582
30583   jresult = (void *)result;
30584   return jresult;
30585 }
30586
30587
30588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30589   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30590
30591   arg1 = (Dali::HoverEvent *)jarg1;
30592   {
30593     try {
30594       delete arg1;
30595     } catch (std::out_of_range& e) {
30596       {
30597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30598       };
30599     } catch (std::exception& e) {
30600       {
30601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30602       };
30603     } catch (Dali::DaliException e) {
30604       {
30605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30606       };
30607     } catch (...) {
30608       {
30609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30610       };
30611     }
30612   }
30613
30614 }
30615
30616
30617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30618   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30619   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30620
30621   arg1 = (Dali::HoverEvent *)jarg1;
30622   arg2 = (Dali::TouchPointContainer *)jarg2;
30623   if (arg1) (arg1)->points = *arg2;
30624 }
30625
30626
30627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30628   void * jresult ;
30629   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30630   Dali::TouchPointContainer *result = 0 ;
30631
30632   arg1 = (Dali::HoverEvent *)jarg1;
30633   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30634   jresult = (void *)result;
30635   return jresult;
30636 }
30637
30638
30639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30640   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30641   unsigned long arg2 ;
30642
30643   arg1 = (Dali::HoverEvent *)jarg1;
30644   arg2 = (unsigned long)jarg2;
30645   if (arg1) (arg1)->time = arg2;
30646 }
30647
30648
30649 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30650   unsigned long jresult ;
30651   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30652   unsigned long result;
30653
30654   arg1 = (Dali::HoverEvent *)jarg1;
30655   result = (unsigned long) ((arg1)->time);
30656   jresult = (unsigned long)result;
30657   return jresult;
30658 }
30659
30660
30661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30662   unsigned int jresult ;
30663   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30664   unsigned int result;
30665
30666   arg1 = (Dali::HoverEvent *)jarg1;
30667   {
30668     try {
30669       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30670     } catch (std::out_of_range& e) {
30671       {
30672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30673       };
30674     } catch (std::exception& e) {
30675       {
30676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30677       };
30678     } catch (Dali::DaliException e) {
30679       {
30680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30681       };
30682     } catch (...) {
30683       {
30684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30685       };
30686     }
30687   }
30688
30689   jresult = result;
30690   return jresult;
30691 }
30692
30693
30694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30695   void * jresult ;
30696   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30697   unsigned int arg2 ;
30698   Dali::TouchPoint *result = 0 ;
30699
30700   arg1 = (Dali::HoverEvent *)jarg1;
30701   arg2 = (unsigned int)jarg2;
30702   {
30703     try {
30704       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30705     } catch (std::out_of_range& e) {
30706       {
30707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30708       };
30709     } catch (std::exception& e) {
30710       {
30711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30712       };
30713     } catch (Dali::DaliException e) {
30714       {
30715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30716       };
30717     } catch (...) {
30718       {
30719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30720       };
30721     }
30722   }
30723
30724   jresult = (void *)result;
30725   return jresult;
30726 }
30727
30728
30729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30730   void * jresult ;
30731   Dali::KeyEvent *result = 0 ;
30732
30733   {
30734     try {
30735       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30736     } catch (std::out_of_range& e) {
30737       {
30738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30739       };
30740     } catch (std::exception& e) {
30741       {
30742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30743       };
30744     } catch (Dali::DaliException e) {
30745       {
30746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30747       };
30748     } catch (...) {
30749       {
30750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30751       };
30752     }
30753   }
30754
30755   jresult = (void *)result;
30756   return jresult;
30757 }
30758
30759
30760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30761   void * jresult ;
30762   std::string *arg1 = 0 ;
30763   std::string *arg2 = 0 ;
30764   int arg3 ;
30765   int arg4 ;
30766   unsigned long arg5 ;
30767   Dali::KeyEvent::State *arg6 = 0 ;
30768   Dali::KeyEvent::State temp6 ;
30769   Dali::KeyEvent *result = 0 ;
30770
30771   if (!jarg1) {
30772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30773     return 0;
30774   }
30775   std::string arg1_str(jarg1);
30776   arg1 = &arg1_str;
30777   if (!jarg2) {
30778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30779     return 0;
30780   }
30781   std::string arg2_str(jarg2);
30782   arg2 = &arg2_str;
30783   arg3 = (int)jarg3;
30784   arg4 = (int)jarg4;
30785   arg5 = (unsigned long)jarg5;
30786   temp6 = (Dali::KeyEvent::State)jarg6;
30787   arg6 = &temp6;
30788   {
30789     try {
30790       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30791     } catch (std::out_of_range& e) {
30792       {
30793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30794       };
30795     } catch (std::exception& e) {
30796       {
30797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30798       };
30799     } catch (Dali::DaliException e) {
30800       {
30801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30802       };
30803     } catch (...) {
30804       {
30805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30806       };
30807     }
30808   }
30809
30810   jresult = (void *)result;
30811
30812   //argout typemap for const std::string&
30813
30814
30815   //argout typemap for const std::string&
30816
30817   return jresult;
30818 }
30819
30820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30821   void * jresult ;
30822   Dali::KeyEvent *arg1 = 0 ;
30823   Dali::KeyEvent *result = 0 ;
30824
30825   arg1 = (Dali::KeyEvent *)jarg1;
30826   if (!arg1) {
30827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30828     return 0;
30829   }
30830   {
30831     try {
30832       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30833     } catch (std::out_of_range& e) {
30834       {
30835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30836       };
30837     } catch (std::exception& e) {
30838       {
30839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30840       };
30841     } catch (Dali::DaliException e) {
30842       {
30843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30844       };
30845     } catch (...) {
30846       {
30847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30848       };
30849     }
30850   }
30851
30852   jresult = (void *)result;
30853   return jresult;
30854 }
30855
30856
30857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30858   void * jresult ;
30859   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30860   Dali::KeyEvent *arg2 = 0 ;
30861   Dali::KeyEvent *result = 0 ;
30862
30863   arg1 = (Dali::KeyEvent *)jarg1;
30864   arg2 = (Dali::KeyEvent *)jarg2;
30865   if (!arg2) {
30866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30867     return 0;
30868   }
30869   {
30870     try {
30871       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
30872     } catch (std::out_of_range& e) {
30873       {
30874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30875       };
30876     } catch (std::exception& e) {
30877       {
30878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30879       };
30880     } catch (Dali::DaliException e) {
30881       {
30882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30883       };
30884     } catch (...) {
30885       {
30886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30887       };
30888     }
30889   }
30890
30891   jresult = (void *)result;
30892   return jresult;
30893 }
30894
30895
30896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
30897   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30898
30899   arg1 = (Dali::KeyEvent *)jarg1;
30900   {
30901     try {
30902       delete arg1;
30903     } catch (std::out_of_range& e) {
30904       {
30905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30906       };
30907     } catch (std::exception& e) {
30908       {
30909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30910       };
30911     } catch (Dali::DaliException e) {
30912       {
30913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30914       };
30915     } catch (...) {
30916       {
30917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30918       };
30919     }
30920   }
30921
30922 }
30923
30924
30925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
30926   unsigned int jresult ;
30927   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30928   bool result;
30929
30930   arg1 = (Dali::KeyEvent *)jarg1;
30931   {
30932     try {
30933       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
30934     } catch (std::out_of_range& e) {
30935       {
30936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30937       };
30938     } catch (std::exception& e) {
30939       {
30940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30941       };
30942     } catch (Dali::DaliException e) {
30943       {
30944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30945       };
30946     } catch (...) {
30947       {
30948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30949       };
30950     }
30951   }
30952
30953   jresult = result;
30954   return jresult;
30955 }
30956
30957
30958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
30959   unsigned int jresult ;
30960   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30961   bool result;
30962
30963   arg1 = (Dali::KeyEvent *)jarg1;
30964   {
30965     try {
30966       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
30967     } catch (std::out_of_range& e) {
30968       {
30969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30970       };
30971     } catch (std::exception& e) {
30972       {
30973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30974       };
30975     } catch (Dali::DaliException e) {
30976       {
30977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30978       };
30979     } catch (...) {
30980       {
30981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30982       };
30983     }
30984   }
30985
30986   jresult = result;
30987   return jresult;
30988 }
30989
30990
30991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
30992   unsigned int jresult ;
30993   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30994   bool result;
30995
30996   arg1 = (Dali::KeyEvent *)jarg1;
30997   {
30998     try {
30999       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31000     } catch (std::out_of_range& e) {
31001       {
31002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31003       };
31004     } catch (std::exception& e) {
31005       {
31006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31007       };
31008     } catch (Dali::DaliException e) {
31009       {
31010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31011       };
31012     } catch (...) {
31013       {
31014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31015       };
31016     }
31017   }
31018
31019   jresult = result;
31020   return jresult;
31021 }
31022
31023
31024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31025   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31026   std::string *arg2 = 0 ;
31027
31028   arg1 = (Dali::KeyEvent *)jarg1;
31029   if (!jarg2) {
31030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31031     return ;
31032   }
31033   std::string arg2_str(jarg2);
31034   arg2 = &arg2_str;
31035   if (arg1) (arg1)->keyPressedName = *arg2;
31036
31037   //argout typemap for const std::string&
31038
31039 }
31040
31041
31042 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31043   char * jresult ;
31044
31045   if( jarg1 == NULL )
31046   {
31047     jresult = SWIG_csharp_string_callback( "" );
31048   }
31049   else
31050   {
31051     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31052     std::string *result = 0;
31053
31054     arg1 = ( Dali::KeyEvent * )jarg1;
31055     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31056     jresult = SWIG_csharp_string_callback( result->c_str() );
31057   }
31058
31059   return jresult;
31060 }
31061
31062
31063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31064   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31065   std::string *arg2 = 0 ;
31066
31067   arg1 = (Dali::KeyEvent *)jarg1;
31068   if (!jarg2) {
31069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31070     return ;
31071   }
31072   std::string arg2_str(jarg2);
31073   arg2 = &arg2_str;
31074   if (arg1) (arg1)->keyPressed = *arg2;
31075
31076   //argout typemap for const std::string&
31077
31078 }
31079
31080
31081 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31082   char * jresult ;
31083   if( NULL == jarg1 )
31084   {
31085     jresult = SWIG_csharp_string_callback( "" );
31086   }
31087   else
31088   {
31089     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31090     std::string *result = 0;
31091
31092     arg1 = ( Dali::KeyEvent * )jarg1;
31093     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31094     jresult = SWIG_csharp_string_callback( result->c_str() );
31095   }
31096   return jresult;
31097 }
31098
31099
31100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31101   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31102   int arg2 ;
31103
31104   arg1 = (Dali::KeyEvent *)jarg1;
31105   arg2 = (int)jarg2;
31106   if (arg1) (arg1)->keyCode = arg2;
31107 }
31108
31109
31110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31111   int jresult ;
31112   if( NULL == jarg1 )
31113   {
31114     jresult = -1;
31115   }
31116   else
31117   {
31118     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31119     int result;
31120
31121     arg1 = ( Dali::KeyEvent * )jarg1;
31122     result = (int)( ( arg1 )->keyCode );
31123     jresult = result;
31124   }
31125   return jresult;
31126 }
31127
31128
31129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31130   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31131   int arg2 ;
31132
31133   arg1 = (Dali::KeyEvent *)jarg1;
31134   arg2 = (int)jarg2;
31135   if (arg1) (arg1)->keyModifier = arg2;
31136 }
31137
31138
31139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31140   int jresult ;
31141   if( jarg1 == NULL )
31142   {
31143     jresult = -1;
31144   }
31145   else
31146   {
31147     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31148     int result;
31149
31150     arg1 = ( Dali::KeyEvent * )jarg1;
31151     result = (int)( ( arg1 )->keyModifier );
31152     jresult = result;
31153   }
31154   return jresult;
31155 }
31156
31157
31158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31159   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31160   unsigned long arg2 ;
31161
31162   arg1 = (Dali::KeyEvent *)jarg1;
31163   arg2 = (unsigned long)jarg2;
31164   if (arg1) (arg1)->time = arg2;
31165 }
31166
31167
31168 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31169   unsigned long jresult ;
31170   if( jarg1 == NULL )
31171   {
31172     jresult = 0;
31173   }
31174   else
31175   {
31176     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31177     unsigned long result;
31178
31179     arg1 = ( Dali::KeyEvent * )jarg1;
31180     result = (unsigned long)( ( arg1 )->time );
31181     jresult = (unsigned long)result;
31182   }
31183   return jresult;
31184 }
31185
31186
31187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31188   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31189   Dali::KeyEvent::State arg2 ;
31190
31191   arg1 = (Dali::KeyEvent *)jarg1;
31192   arg2 = (Dali::KeyEvent::State)jarg2;
31193   if (arg1) (arg1)->state = arg2;
31194 }
31195
31196
31197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31198   int jresult ;
31199   if( jarg1 == NULL )
31200   {
31201     jresult = -1;
31202   }
31203   else
31204   {
31205     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31206     Dali::KeyEvent::State result;
31207
31208     arg1 = ( Dali::KeyEvent * )jarg1;
31209     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31210     jresult = (int)result;
31211   }
31212   return jresult;
31213 }
31214
31215 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31216   char * jresult ;
31217   std::string result;
31218   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31219
31220   arg1 = (Dali::KeyEvent *)jarg1;
31221   if (!arg1) {
31222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31223     return 0;
31224   }
31225   {
31226     try {
31227       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31228     } catch (std::out_of_range& e) {
31229       {
31230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31231       };
31232     } catch (std::exception& e) {
31233       {
31234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31235       };
31236     } catch (Dali::DaliException e) {
31237       {
31238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31239       };
31240     } catch (...) {
31241       {
31242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31243       };
31244     }
31245
31246   }
31247
31248   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31249   return jresult;
31250 }
31251
31252
31253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31254   void * jresult ;
31255   Dali::LongPressGestureDetector *result = 0 ;
31256
31257   {
31258     try {
31259       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31260     } catch (std::out_of_range& e) {
31261       {
31262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31263       };
31264     } catch (std::exception& e) {
31265       {
31266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31267       };
31268     } catch (Dali::DaliException e) {
31269       {
31270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31271       };
31272     } catch (...) {
31273       {
31274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31275       };
31276     }
31277   }
31278
31279   jresult = (void *)result;
31280   return jresult;
31281 }
31282
31283
31284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31285   void * jresult ;
31286   Dali::LongPressGestureDetector result;
31287
31288   {
31289     try {
31290       result = Dali::LongPressGestureDetector::New();
31291     } catch (std::out_of_range& e) {
31292       {
31293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31294       };
31295     } catch (std::exception& e) {
31296       {
31297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31298       };
31299     } catch (Dali::DaliException e) {
31300       {
31301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31302       };
31303     } catch (...) {
31304       {
31305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31306       };
31307     }
31308   }
31309
31310   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31311   return jresult;
31312 }
31313
31314
31315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31316   void * jresult ;
31317   unsigned int arg1 ;
31318   Dali::LongPressGestureDetector result;
31319
31320   arg1 = (unsigned int)jarg1;
31321   {
31322     try {
31323       result = Dali::LongPressGestureDetector::New(arg1);
31324     } catch (std::out_of_range& e) {
31325       {
31326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31327       };
31328     } catch (std::exception& e) {
31329       {
31330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31331       };
31332     } catch (Dali::DaliException e) {
31333       {
31334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31335       };
31336     } catch (...) {
31337       {
31338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31339       };
31340     }
31341   }
31342
31343   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31344   return jresult;
31345 }
31346
31347
31348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31349   void * jresult ;
31350   unsigned int arg1 ;
31351   unsigned int arg2 ;
31352   Dali::LongPressGestureDetector result;
31353
31354   arg1 = (unsigned int)jarg1;
31355   arg2 = (unsigned int)jarg2;
31356   {
31357     try {
31358       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31359     } catch (std::out_of_range& e) {
31360       {
31361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31362       };
31363     } catch (std::exception& e) {
31364       {
31365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31366       };
31367     } catch (Dali::DaliException e) {
31368       {
31369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31370       };
31371     } catch (...) {
31372       {
31373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31374       };
31375     }
31376   }
31377
31378   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31379   return jresult;
31380 }
31381
31382
31383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31384   void * jresult ;
31385   Dali::BaseHandle arg1 ;
31386   Dali::BaseHandle *argp1 ;
31387   Dali::LongPressGestureDetector result;
31388
31389   argp1 = (Dali::BaseHandle *)jarg1;
31390   if (!argp1) {
31391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31392     return 0;
31393   }
31394   arg1 = *argp1;
31395   {
31396     try {
31397       result = Dali::LongPressGestureDetector::DownCast(arg1);
31398     } catch (std::out_of_range& e) {
31399       {
31400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31401       };
31402     } catch (std::exception& e) {
31403       {
31404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31405       };
31406     } catch (Dali::DaliException e) {
31407       {
31408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31409       };
31410     } catch (...) {
31411       {
31412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31413       };
31414     }
31415   }
31416
31417   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31418   return jresult;
31419 }
31420
31421
31422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31423   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31424
31425   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31426   {
31427     try {
31428       delete arg1;
31429     } catch (std::out_of_range& e) {
31430       {
31431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31432       };
31433     } catch (std::exception& e) {
31434       {
31435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31436       };
31437     } catch (Dali::DaliException e) {
31438       {
31439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31440       };
31441     } catch (...) {
31442       {
31443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31444       };
31445     }
31446   }
31447
31448 }
31449
31450
31451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31452   void * jresult ;
31453   Dali::LongPressGestureDetector *arg1 = 0 ;
31454   Dali::LongPressGestureDetector *result = 0 ;
31455
31456   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31457   if (!arg1) {
31458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31459     return 0;
31460   }
31461   {
31462     try {
31463       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31464     } catch (std::out_of_range& e) {
31465       {
31466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31467       };
31468     } catch (std::exception& e) {
31469       {
31470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31471       };
31472     } catch (Dali::DaliException e) {
31473       {
31474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31475       };
31476     } catch (...) {
31477       {
31478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31479       };
31480     }
31481   }
31482
31483   jresult = (void *)result;
31484   return jresult;
31485 }
31486
31487
31488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31489   void * jresult ;
31490   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31491   Dali::LongPressGestureDetector *arg2 = 0 ;
31492   Dali::LongPressGestureDetector *result = 0 ;
31493
31494   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31495   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31496   if (!arg2) {
31497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31498     return 0;
31499   }
31500   {
31501     try {
31502       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31503     } catch (std::out_of_range& e) {
31504       {
31505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31506       };
31507     } catch (std::exception& e) {
31508       {
31509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31510       };
31511     } catch (Dali::DaliException e) {
31512       {
31513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31514       };
31515     } catch (...) {
31516       {
31517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31518       };
31519     }
31520   }
31521
31522   jresult = (void *)result;
31523   return jresult;
31524 }
31525
31526
31527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31528   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31529   unsigned int arg2 ;
31530
31531   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31532   arg2 = (unsigned int)jarg2;
31533   {
31534     try {
31535       (arg1)->SetTouchesRequired(arg2);
31536     } catch (std::out_of_range& e) {
31537       {
31538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31539       };
31540     } catch (std::exception& e) {
31541       {
31542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31543       };
31544     } catch (Dali::DaliException e) {
31545       {
31546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31547       };
31548     } catch (...) {
31549       {
31550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31551       };
31552     }
31553   }
31554
31555 }
31556
31557
31558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31559   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31560   unsigned int arg2 ;
31561   unsigned int arg3 ;
31562
31563   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31564   arg2 = (unsigned int)jarg2;
31565   arg3 = (unsigned int)jarg3;
31566   {
31567     try {
31568       (arg1)->SetTouchesRequired(arg2,arg3);
31569     } catch (std::out_of_range& e) {
31570       {
31571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31572       };
31573     } catch (std::exception& e) {
31574       {
31575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31576       };
31577     } catch (Dali::DaliException e) {
31578       {
31579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31580       };
31581     } catch (...) {
31582       {
31583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31584       };
31585     }
31586   }
31587
31588 }
31589
31590
31591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31592   unsigned int jresult ;
31593   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31594   unsigned int result;
31595
31596   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31597   {
31598     try {
31599       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31600     } catch (std::out_of_range& e) {
31601       {
31602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31603       };
31604     } catch (std::exception& e) {
31605       {
31606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31607       };
31608     } catch (Dali::DaliException e) {
31609       {
31610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31611       };
31612     } catch (...) {
31613       {
31614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31615       };
31616     }
31617   }
31618
31619   jresult = result;
31620   return jresult;
31621 }
31622
31623
31624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31625   unsigned int jresult ;
31626   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31627   unsigned int result;
31628
31629   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31630   {
31631     try {
31632       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31633     } catch (std::out_of_range& e) {
31634       {
31635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31636       };
31637     } catch (std::exception& e) {
31638       {
31639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31640       };
31641     } catch (Dali::DaliException e) {
31642       {
31643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31644       };
31645     } catch (...) {
31646       {
31647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31648       };
31649     }
31650   }
31651
31652   jresult = result;
31653   return jresult;
31654 }
31655
31656
31657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31658   void * jresult ;
31659   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31660   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31661
31662   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31663   {
31664     try {
31665       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31666     } catch (std::out_of_range& e) {
31667       {
31668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31669       };
31670     } catch (std::exception& e) {
31671       {
31672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31673       };
31674     } catch (Dali::DaliException e) {
31675       {
31676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31677       };
31678     } catch (...) {
31679       {
31680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31681       };
31682     }
31683   }
31684
31685   jresult = (void *)result;
31686   return jresult;
31687 }
31688
31689
31690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31691   void * jresult ;
31692   Dali::Gesture::State arg1 ;
31693   Dali::LongPressGesture *result = 0 ;
31694
31695   arg1 = (Dali::Gesture::State)jarg1;
31696   {
31697     try {
31698       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31699     } catch (std::out_of_range& e) {
31700       {
31701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31702       };
31703     } catch (std::exception& e) {
31704       {
31705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31706       };
31707     } catch (Dali::DaliException e) {
31708       {
31709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31710       };
31711     } catch (...) {
31712       {
31713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31714       };
31715     }
31716   }
31717
31718   jresult = (void *)result;
31719   return jresult;
31720 }
31721
31722
31723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31724   void * jresult ;
31725   Dali::LongPressGesture *arg1 = 0 ;
31726   Dali::LongPressGesture *result = 0 ;
31727
31728   arg1 = (Dali::LongPressGesture *)jarg1;
31729   if (!arg1) {
31730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31731     return 0;
31732   }
31733   {
31734     try {
31735       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31736     } catch (std::out_of_range& e) {
31737       {
31738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31739       };
31740     } catch (std::exception& e) {
31741       {
31742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31743       };
31744     } catch (Dali::DaliException e) {
31745       {
31746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31747       };
31748     } catch (...) {
31749       {
31750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31751       };
31752     }
31753   }
31754
31755   jresult = (void *)result;
31756   return jresult;
31757 }
31758
31759
31760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31761   void * jresult ;
31762   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31763   Dali::LongPressGesture *arg2 = 0 ;
31764   Dali::LongPressGesture *result = 0 ;
31765
31766   arg1 = (Dali::LongPressGesture *)jarg1;
31767   arg2 = (Dali::LongPressGesture *)jarg2;
31768   if (!arg2) {
31769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31770     return 0;
31771   }
31772   {
31773     try {
31774       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31775     } catch (std::out_of_range& e) {
31776       {
31777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31778       };
31779     } catch (std::exception& e) {
31780       {
31781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31782       };
31783     } catch (Dali::DaliException e) {
31784       {
31785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31786       };
31787     } catch (...) {
31788       {
31789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31790       };
31791     }
31792   }
31793
31794   jresult = (void *)result;
31795   return jresult;
31796 }
31797
31798
31799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31800   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31801
31802   arg1 = (Dali::LongPressGesture *)jarg1;
31803   {
31804     try {
31805       delete arg1;
31806     } catch (std::out_of_range& e) {
31807       {
31808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31809       };
31810     } catch (std::exception& e) {
31811       {
31812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31813       };
31814     } catch (Dali::DaliException e) {
31815       {
31816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31817       };
31818     } catch (...) {
31819       {
31820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31821       };
31822     }
31823   }
31824
31825 }
31826
31827
31828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31829   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31830   unsigned int arg2 ;
31831
31832   arg1 = (Dali::LongPressGesture *)jarg1;
31833   arg2 = (unsigned int)jarg2;
31834   if (arg1) (arg1)->numberOfTouches = arg2;
31835 }
31836
31837
31838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31839   unsigned int jresult ;
31840   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31841   unsigned int result;
31842
31843   arg1 = (Dali::LongPressGesture *)jarg1;
31844   result = (unsigned int) ((arg1)->numberOfTouches);
31845   jresult = result;
31846   return jresult;
31847 }
31848
31849
31850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31851   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31852   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31853
31854   arg1 = (Dali::LongPressGesture *)jarg1;
31855   arg2 = (Dali::Vector2 *)jarg2;
31856   if (arg1) (arg1)->screenPoint = *arg2;
31857 }
31858
31859
31860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
31861   void * jresult ;
31862   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31863   Dali::Vector2 *result = 0 ;
31864
31865   arg1 = (Dali::LongPressGesture *)jarg1;
31866   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
31867   jresult = (void *)result;
31868   return jresult;
31869 }
31870
31871
31872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
31873   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31874   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31875
31876   arg1 = (Dali::LongPressGesture *)jarg1;
31877   arg2 = (Dali::Vector2 *)jarg2;
31878   if (arg1) (arg1)->localPoint = *arg2;
31879 }
31880
31881
31882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
31883   void * jresult ;
31884   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31885   Dali::Vector2 *result = 0 ;
31886
31887   arg1 = (Dali::LongPressGesture *)jarg1;
31888   result = (Dali::Vector2 *)& ((arg1)->localPoint);
31889   jresult = (void *)result;
31890   return jresult;
31891 }
31892
31893
31894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
31895   void * jresult ;
31896   Dali::WheelEvent *result = 0 ;
31897
31898   {
31899     try {
31900       result = (Dali::WheelEvent *)new Dali::WheelEvent();
31901     } catch (std::out_of_range& e) {
31902       {
31903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31904       };
31905     } catch (std::exception& e) {
31906       {
31907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31908       };
31909     } catch (Dali::DaliException e) {
31910       {
31911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31912       };
31913     } catch (...) {
31914       {
31915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31916       };
31917     }
31918   }
31919
31920   jresult = (void *)result;
31921   return jresult;
31922 }
31923
31924
31925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
31926   void * jresult ;
31927   Dali::WheelEvent::Type arg1 ;
31928   int arg2 ;
31929   unsigned int arg3 ;
31930   Dali::Vector2 arg4 ;
31931   int arg5 ;
31932   unsigned int arg6 ;
31933   Dali::Vector2 *argp4 ;
31934   Dali::WheelEvent *result = 0 ;
31935
31936   arg1 = (Dali::WheelEvent::Type)jarg1;
31937   arg2 = (int)jarg2;
31938   arg3 = (unsigned int)jarg3;
31939   argp4 = (Dali::Vector2 *)jarg4;
31940   if (!argp4) {
31941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
31942     return 0;
31943   }
31944   arg4 = *argp4;
31945   arg5 = (int)jarg5;
31946   arg6 = (unsigned int)jarg6;
31947   {
31948     try {
31949       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
31950     } catch (std::out_of_range& e) {
31951       {
31952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31953       };
31954     } catch (std::exception& e) {
31955       {
31956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31957       };
31958     } catch (Dali::DaliException e) {
31959       {
31960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31961       };
31962     } catch (...) {
31963       {
31964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31965       };
31966     }
31967   }
31968
31969   jresult = (void *)result;
31970   return jresult;
31971 }
31972
31973
31974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
31975   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
31976
31977   arg1 = (Dali::WheelEvent *)jarg1;
31978   {
31979     try {
31980       delete arg1;
31981     } catch (std::out_of_range& e) {
31982       {
31983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31984       };
31985     } catch (std::exception& e) {
31986       {
31987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31988       };
31989     } catch (Dali::DaliException e) {
31990       {
31991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31992       };
31993     } catch (...) {
31994       {
31995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31996       };
31997     }
31998   }
31999
32000 }
32001
32002
32003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32004   unsigned int jresult ;
32005   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32006   bool result;
32007
32008   arg1 = (Dali::WheelEvent *)jarg1;
32009   {
32010     try {
32011       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32012     } catch (std::out_of_range& e) {
32013       {
32014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32015       };
32016     } catch (std::exception& e) {
32017       {
32018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32019       };
32020     } catch (Dali::DaliException e) {
32021       {
32022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32023       };
32024     } catch (...) {
32025       {
32026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32027       };
32028     }
32029   }
32030
32031   jresult = result;
32032   return jresult;
32033 }
32034
32035
32036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32037   unsigned int jresult ;
32038   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32039   bool result;
32040
32041   arg1 = (Dali::WheelEvent *)jarg1;
32042   {
32043     try {
32044       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32045     } catch (std::out_of_range& e) {
32046       {
32047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32048       };
32049     } catch (std::exception& e) {
32050       {
32051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32052       };
32053     } catch (Dali::DaliException e) {
32054       {
32055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32056       };
32057     } catch (...) {
32058       {
32059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32060       };
32061     }
32062   }
32063
32064   jresult = result;
32065   return jresult;
32066 }
32067
32068
32069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32070   unsigned int jresult ;
32071   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32072   bool result;
32073
32074   arg1 = (Dali::WheelEvent *)jarg1;
32075   {
32076     try {
32077       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32078     } catch (std::out_of_range& e) {
32079       {
32080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32081       };
32082     } catch (std::exception& e) {
32083       {
32084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32085       };
32086     } catch (Dali::DaliException e) {
32087       {
32088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32089       };
32090     } catch (...) {
32091       {
32092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32093       };
32094     }
32095   }
32096
32097   jresult = result;
32098   return jresult;
32099 }
32100
32101
32102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32103   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32104   Dali::WheelEvent::Type arg2 ;
32105
32106   arg1 = (Dali::WheelEvent *)jarg1;
32107   arg2 = (Dali::WheelEvent::Type)jarg2;
32108   if (arg1) (arg1)->type = arg2;
32109 }
32110
32111
32112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32113   int jresult ;
32114   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32115   Dali::WheelEvent::Type result;
32116
32117   arg1 = (Dali::WheelEvent *)jarg1;
32118   result = (Dali::WheelEvent::Type) ((arg1)->type);
32119   jresult = (int)result;
32120   return jresult;
32121 }
32122
32123
32124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32125   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32126   int arg2 ;
32127
32128   arg1 = (Dali::WheelEvent *)jarg1;
32129   arg2 = (int)jarg2;
32130   if (arg1) (arg1)->direction = arg2;
32131 }
32132
32133
32134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32135   int jresult ;
32136   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32137   int result;
32138
32139   arg1 = (Dali::WheelEvent *)jarg1;
32140   result = (int) ((arg1)->direction);
32141   jresult = result;
32142   return jresult;
32143 }
32144
32145
32146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32147   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32148   unsigned int arg2 ;
32149
32150   arg1 = (Dali::WheelEvent *)jarg1;
32151   arg2 = (unsigned int)jarg2;
32152   if (arg1) (arg1)->modifiers = arg2;
32153 }
32154
32155
32156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32157   unsigned int jresult ;
32158   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32159   unsigned int result;
32160
32161   arg1 = (Dali::WheelEvent *)jarg1;
32162   result = (unsigned int) ((arg1)->modifiers);
32163   jresult = result;
32164   return jresult;
32165 }
32166
32167
32168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32169   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32170   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32171
32172   arg1 = (Dali::WheelEvent *)jarg1;
32173   arg2 = (Dali::Vector2 *)jarg2;
32174   if (arg1) (arg1)->point = *arg2;
32175 }
32176
32177
32178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32179   void * jresult ;
32180   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32181   Dali::Vector2 *result = 0 ;
32182
32183   arg1 = (Dali::WheelEvent *)jarg1;
32184   result = (Dali::Vector2 *)& ((arg1)->point);
32185   jresult = (void *)result;
32186   return jresult;
32187 }
32188
32189
32190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32191   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32192   int arg2 ;
32193
32194   arg1 = (Dali::WheelEvent *)jarg1;
32195   arg2 = (int)jarg2;
32196   if (arg1) (arg1)->z = arg2;
32197 }
32198
32199
32200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32201   int jresult ;
32202   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32203   int result;
32204
32205   arg1 = (Dali::WheelEvent *)jarg1;
32206   result = (int) ((arg1)->z);
32207   jresult = result;
32208   return jresult;
32209 }
32210
32211
32212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32213   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32214   unsigned int arg2 ;
32215
32216   arg1 = (Dali::WheelEvent *)jarg1;
32217   arg2 = (unsigned int)jarg2;
32218   if (arg1) (arg1)->timeStamp = arg2;
32219 }
32220
32221
32222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32223   unsigned int jresult ;
32224   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32225   unsigned int result;
32226
32227   arg1 = (Dali::WheelEvent *)jarg1;
32228   result = (unsigned int) ((arg1)->timeStamp);
32229   jresult = result;
32230   return jresult;
32231 }
32232
32233 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32234   char * jresult ;
32235   Dali::KeyEvent *arg1 = 0 ;
32236   std::string result;
32237
32238   arg1 = (Dali::KeyEvent *)jarg1;
32239   if (!arg1) {
32240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32241     return 0;
32242   }
32243   {
32244     try {
32245       result = arg1->GetDeviceName();
32246     } catch (std::out_of_range& e) {
32247       {
32248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32249       };
32250     } catch (std::exception& e) {
32251       {
32252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32253       };
32254     } catch (Dali::DaliException e) {
32255       {
32256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32257       };
32258     } catch (...) {
32259       {
32260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32261       };
32262     }
32263   }
32264
32265   jresult = SWIG_csharp_string_callback((&result)->c_str());
32266   return jresult;
32267 }
32268
32269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32270   int jresult ;
32271   Dali::KeyEvent *arg1 = 0 ;
32272   Dali::Device::Class::Type result;
32273
32274   arg1 = (Dali::KeyEvent *)jarg1;
32275   if (!arg1) {
32276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32277     return 0;
32278   }
32279   {
32280     try {
32281       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32282     } catch (std::out_of_range& e) {
32283       {
32284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32285       };
32286     } catch (std::exception& e) {
32287       {
32288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32289       };
32290     } catch (Dali::DaliException e) {
32291       {
32292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32293       };
32294     } catch (...) {
32295       {
32296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32297       };
32298     }
32299   }
32300
32301   jresult = (int)result;
32302   return jresult;
32303 }
32304
32305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32306   int jresult ;
32307   Dali::KeyEvent *arg1 = 0 ;
32308   Dali::Device::Subclass::Type result;
32309
32310   arg1 = (Dali::KeyEvent *)jarg1;
32311   if (!arg1) {
32312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32313     return 0;
32314   }
32315   {
32316     try {
32317       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32318     } catch (std::out_of_range& e) {
32319       {
32320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32321       };
32322     } catch (std::exception& e) {
32323       {
32324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32325       };
32326     } catch (Dali::DaliException e) {
32327       {
32328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32329       };
32330     } catch (...) {
32331       {
32332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32333       };
32334     }
32335   }
32336
32337   jresult = (int)result;
32338   return jresult;
32339 }
32340
32341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32342   Dali::Actor arg1 ;
32343   Dali::Actor *argp1 ;
32344
32345   argp1 = (Dali::Actor *)jarg1;
32346   if (!argp1) {
32347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32348     return ;
32349   }
32350   arg1 = *argp1;
32351   {
32352     try {
32353       arg1.Raise();
32354     } catch (std::out_of_range& e) {
32355       {
32356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32357       };
32358     } catch (std::exception& e) {
32359       {
32360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32361       };
32362     } catch (Dali::DaliException e) {
32363       {
32364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32365       };
32366     } catch (...) {
32367       {
32368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32369       };
32370     }
32371   }
32372
32373 }
32374
32375
32376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32377   Dali::Actor arg1 ;
32378   Dali::Actor *argp1 ;
32379
32380   argp1 = (Dali::Actor *)jarg1;
32381   if (!argp1) {
32382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32383     return ;
32384   }
32385   arg1 = *argp1;
32386   {
32387     try {
32388       arg1.Lower();
32389     } catch (std::out_of_range& e) {
32390       {
32391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32392       };
32393     } catch (std::exception& e) {
32394       {
32395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32396       };
32397     } catch (Dali::DaliException e) {
32398       {
32399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32400       };
32401     } catch (...) {
32402       {
32403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32404       };
32405     }
32406   }
32407
32408 }
32409
32410
32411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32412   Dali::Actor arg1 ;
32413   Dali::Actor *argp1 ;
32414
32415   argp1 = (Dali::Actor *)jarg1;
32416   if (!argp1) {
32417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32418     return ;
32419   }
32420   arg1 = *argp1;
32421   {
32422     try {
32423       arg1.RaiseToTop();
32424     } catch (std::out_of_range& e) {
32425       {
32426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32427       };
32428     } catch (std::exception& e) {
32429       {
32430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32431       };
32432     } catch (Dali::DaliException e) {
32433       {
32434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32435       };
32436     } catch (...) {
32437       {
32438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32439       };
32440     }
32441   }
32442
32443 }
32444
32445
32446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32447   Dali::Actor arg1 ;
32448   Dali::Actor *argp1 ;
32449
32450   argp1 = (Dali::Actor *)jarg1;
32451   if (!argp1) {
32452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32453     return ;
32454   }
32455   arg1 = *argp1;
32456   {
32457     try {
32458       arg1.LowerToBottom();
32459     } catch (std::out_of_range& e) {
32460       {
32461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32462       };
32463     } catch (std::exception& e) {
32464       {
32465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32466       };
32467     } catch (Dali::DaliException e) {
32468       {
32469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32470       };
32471     } catch (...) {
32472       {
32473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32474       };
32475     }
32476   }
32477
32478 }
32479
32480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32481   Dali::Actor arg1 ;
32482   Dali::Actor arg2 ;
32483   Dali::Actor *argp1 ;
32484   Dali::Actor *argp2 ;
32485
32486   argp1 = (Dali::Actor *)jarg1;
32487   if (!argp1) {
32488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32489     return ;
32490   }
32491   arg1 = *argp1;
32492   argp2 = (Dali::Actor *)jarg2;
32493   if (!argp2) {
32494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32495     return ;
32496   }
32497   arg2 = *argp2;
32498   {
32499     try {
32500       arg1.RaiseAbove(arg2);
32501     } catch (std::out_of_range& e) {
32502       {
32503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32504       };
32505     } catch (std::exception& e) {
32506       {
32507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32508       };
32509     } catch (Dali::DaliException e) {
32510       {
32511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32512       };
32513     } catch (...) {
32514       {
32515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32516       };
32517     }
32518   }
32519
32520 }
32521
32522
32523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32524   Dali::Actor arg1 ;
32525   Dali::Actor arg2 ;
32526   Dali::Actor *argp1 ;
32527   Dali::Actor *argp2 ;
32528
32529   argp1 = (Dali::Actor *)jarg1;
32530   if (!argp1) {
32531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32532     return ;
32533   }
32534   arg1 = *argp1;
32535   argp2 = (Dali::Actor *)jarg2;
32536   if (!argp2) {
32537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32538     return ;
32539   }
32540   arg2 = *argp2;
32541   {
32542     try {
32543       arg1.LowerBelow(arg2);
32544     } catch (std::out_of_range& e) {
32545       {
32546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32547       };
32548     } catch (std::exception& e) {
32549       {
32550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32551       };
32552     } catch (Dali::DaliException e) {
32553       {
32554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32555       };
32556     } catch (...) {
32557       {
32558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32559       };
32560     }
32561   }
32562
32563 }
32564
32565
32566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32567   void * jresult ;
32568   Dali::Actor arg1 ;
32569   Dali::Actor *argp1 ;
32570   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32571
32572   argp1 = (Dali::Actor *)jarg1;
32573   if (!argp1) {
32574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32575     return 0;
32576   }
32577   arg1 = *argp1;
32578   {
32579     try {
32580       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32581     } catch (std::out_of_range& e) {
32582       {
32583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32584       };
32585     } catch (std::exception& e) {
32586       {
32587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32588       };
32589     } catch (Dali::DaliException e) {
32590       {
32591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32592       };
32593     } catch (...) {
32594       {
32595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32596       };
32597     }
32598   }
32599
32600   jresult = (void *)result;
32601   return jresult;
32602 }
32603
32604
32605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32606   void * jresult ;
32607   Dali::Actor *arg1 ;
32608   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32609
32610   arg1 = (Dali::Actor *)jarg1;
32611   {
32612     try {
32613       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32614     } catch (std::out_of_range& e) {
32615       {
32616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32617       };
32618     } catch (std::exception& e) {
32619       {
32620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32621       };
32622     } catch (Dali::DaliException e) {
32623       {
32624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32625       };
32626     } catch (...) {
32627       {
32628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32629       };
32630     }
32631   }
32632
32633   jresult = (void *)result;
32634   return jresult;
32635 }
32636
32637
32638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32639   int jresult ;
32640   int result;
32641
32642   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32643   jresult = (int)result;
32644   return jresult;
32645 }
32646
32647
32648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32649   int jresult ;
32650   int result;
32651
32652   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32653   jresult = (int)result;
32654   return jresult;
32655 }
32656
32657
32658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32659   int jresult ;
32660   int result;
32661
32662   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32663   jresult = (int)result;
32664   return jresult;
32665 }
32666
32667
32668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32669   int jresult ;
32670   int result;
32671
32672   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32673   jresult = (int)result;
32674   return jresult;
32675 }
32676
32677
32678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32679   int jresult ;
32680   int result;
32681
32682   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32683   jresult = (int)result;
32684   return jresult;
32685 }
32686
32687
32688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32689   int jresult ;
32690   int result;
32691
32692   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32693   jresult = (int)result;
32694   return jresult;
32695 }
32696
32697
32698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32699   int jresult ;
32700   int result;
32701
32702   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32703   jresult = (int)result;
32704   return jresult;
32705 }
32706
32707
32708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32709   int jresult ;
32710   int result;
32711
32712   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32713   jresult = (int)result;
32714   return jresult;
32715 }
32716
32717
32718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32719   int jresult ;
32720   int result;
32721
32722   result = (int)Dali::Actor::Property::SIZE;
32723   jresult = (int)result;
32724   return jresult;
32725 }
32726
32727
32728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32729   int jresult ;
32730   int result;
32731
32732   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32733   jresult = (int)result;
32734   return jresult;
32735 }
32736
32737
32738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32739   int jresult ;
32740   int result;
32741
32742   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32743   jresult = (int)result;
32744   return jresult;
32745 }
32746
32747
32748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32749   int jresult ;
32750   int result;
32751
32752   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32753   jresult = (int)result;
32754   return jresult;
32755 }
32756
32757
32758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32759   int jresult ;
32760   int result;
32761
32762   result = (int)Dali::Actor::Property::POSITION;
32763   jresult = (int)result;
32764   return jresult;
32765 }
32766
32767
32768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32769   int jresult ;
32770   int result;
32771
32772   result = (int)Dali::Actor::Property::POSITION_X;
32773   jresult = (int)result;
32774   return jresult;
32775 }
32776
32777
32778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32779   int jresult ;
32780   int result;
32781
32782   result = (int)Dali::Actor::Property::POSITION_Y;
32783   jresult = (int)result;
32784   return jresult;
32785 }
32786
32787
32788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32789   int jresult ;
32790   int result;
32791
32792   result = (int)Dali::Actor::Property::POSITION_Z;
32793   jresult = (int)result;
32794   return jresult;
32795 }
32796
32797
32798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32799   int jresult ;
32800   int result;
32801
32802   result = (int)Dali::Actor::Property::WORLD_POSITION;
32803   jresult = (int)result;
32804   return jresult;
32805 }
32806
32807
32808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32809   int jresult ;
32810   int result;
32811
32812   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32813   jresult = (int)result;
32814   return jresult;
32815 }
32816
32817
32818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32819   int jresult ;
32820   int result;
32821
32822   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32823   jresult = (int)result;
32824   return jresult;
32825 }
32826
32827
32828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32829   int jresult ;
32830   int result;
32831
32832   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32833   jresult = (int)result;
32834   return jresult;
32835 }
32836
32837
32838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32839   int jresult ;
32840   int result;
32841
32842   result = (int)Dali::Actor::Property::ORIENTATION;
32843   jresult = (int)result;
32844   return jresult;
32845 }
32846
32847
32848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
32849   int jresult ;
32850   int result;
32851
32852   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
32853   jresult = (int)result;
32854   return jresult;
32855 }
32856
32857
32858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
32859   int jresult ;
32860   int result;
32861
32862   result = (int)Dali::Actor::Property::SCALE;
32863   jresult = (int)result;
32864   return jresult;
32865 }
32866
32867
32868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
32869   int jresult ;
32870   int result;
32871
32872   result = (int)Dali::Actor::Property::SCALE_X;
32873   jresult = (int)result;
32874   return jresult;
32875 }
32876
32877
32878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
32879   int jresult ;
32880   int result;
32881
32882   result = (int)Dali::Actor::Property::SCALE_Y;
32883   jresult = (int)result;
32884   return jresult;
32885 }
32886
32887
32888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
32889   int jresult ;
32890   int result;
32891
32892   result = (int)Dali::Actor::Property::SCALE_Z;
32893   jresult = (int)result;
32894   return jresult;
32895 }
32896
32897
32898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
32899   int jresult ;
32900   int result;
32901
32902   result = (int)Dali::Actor::Property::WORLD_SCALE;
32903   jresult = (int)result;
32904   return jresult;
32905 }
32906
32907
32908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
32909   int jresult ;
32910   int result;
32911
32912   result = (int)Dali::Actor::Property::VISIBLE;
32913   jresult = (int)result;
32914   return jresult;
32915 }
32916
32917
32918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
32919   int jresult ;
32920   int result;
32921
32922   result = (int)Dali::Actor::Property::COLOR;
32923   jresult = (int)result;
32924   return jresult;
32925 }
32926
32927
32928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
32929   int jresult ;
32930   int result;
32931
32932   result = (int)Dali::Actor::Property::COLOR_RED;
32933   jresult = (int)result;
32934   return jresult;
32935 }
32936
32937
32938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
32939   int jresult ;
32940   int result;
32941
32942   result = (int)Dali::Actor::Property::COLOR_GREEN;
32943   jresult = (int)result;
32944   return jresult;
32945 }
32946
32947
32948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
32949   int jresult ;
32950   int result;
32951
32952   result = (int)Dali::Actor::Property::COLOR_BLUE;
32953   jresult = (int)result;
32954   return jresult;
32955 }
32956
32957
32958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
32959   int jresult ;
32960   int result;
32961
32962   result = (int)Dali::Actor::Property::COLOR_ALPHA;
32963   jresult = (int)result;
32964   return jresult;
32965 }
32966
32967
32968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
32969   int jresult ;
32970   int result;
32971
32972   result = (int)Dali::Actor::Property::WORLD_COLOR;
32973   jresult = (int)result;
32974   return jresult;
32975 }
32976
32977
32978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
32979   int jresult ;
32980   int result;
32981
32982   result = (int)Dali::Actor::Property::WORLD_MATRIX;
32983   jresult = (int)result;
32984   return jresult;
32985 }
32986
32987
32988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
32989   int jresult ;
32990   int result;
32991
32992   result = (int)Dali::Actor::Property::NAME;
32993   jresult = (int)result;
32994   return jresult;
32995 }
32996
32997
32998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
32999   int jresult ;
33000   int result;
33001
33002   result = (int)Dali::Actor::Property::SENSITIVE;
33003   jresult = (int)result;
33004   return jresult;
33005 }
33006
33007
33008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33009   int jresult ;
33010   int result;
33011
33012   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33013   jresult = (int)result;
33014   return jresult;
33015 }
33016
33017
33018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33019   int jresult ;
33020   int result;
33021
33022   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33023   jresult = (int)result;
33024   return jresult;
33025 }
33026
33027
33028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33029   int jresult ;
33030   int result;
33031
33032   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33033   jresult = (int)result;
33034   return jresult;
33035 }
33036
33037
33038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33039   int jresult ;
33040   int result;
33041
33042   result = (int)Dali::Actor::Property::COLOR_MODE;
33043   jresult = (int)result;
33044   return jresult;
33045 }
33046
33047
33048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33049   int jresult ;
33050   int result;
33051
33052   result = (int)Dali::Actor::Property::DRAW_MODE;
33053   jresult = (int)result;
33054   return jresult;
33055 }
33056
33057
33058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33059   int jresult ;
33060   int result;
33061
33062   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33063   jresult = (int)result;
33064   return jresult;
33065 }
33066
33067
33068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33069   int jresult ;
33070   int result;
33071
33072   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33073   jresult = (int)result;
33074   return jresult;
33075 }
33076
33077
33078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33079   int jresult ;
33080   int result;
33081
33082   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33083   jresult = (int)result;
33084   return jresult;
33085 }
33086
33087
33088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33089   int jresult ;
33090   int result;
33091
33092   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33093   jresult = (int)result;
33094   return jresult;
33095 }
33096
33097
33098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33099   int jresult ;
33100   int result;
33101
33102   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33103   jresult = (int)result;
33104   return jresult;
33105 }
33106
33107
33108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33109   int jresult ;
33110   int result;
33111
33112   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33113   jresult = (int)result;
33114   return jresult;
33115 }
33116
33117
33118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33119   int jresult ;
33120   int result;
33121
33122   result = (int)Dali::Actor::Property::PADDING;
33123   jresult = (int)result;
33124   return jresult;
33125 }
33126
33127
33128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33129   int jresult ;
33130   int result;
33131
33132   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33133   jresult = (int)result;
33134   return jresult;
33135 }
33136
33137
33138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33139   int jresult ;
33140   int result;
33141
33142   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33143   jresult = (int)result;
33144   return jresult;
33145 }
33146
33147
33148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33149   int jresult ;
33150   int result;
33151
33152   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33153   jresult = (int)result;
33154   return jresult;
33155 }
33156
33157
33158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33159   int jresult ;
33160   int result;
33161
33162   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33163   jresult = (int)result;
33164   return jresult;
33165 }
33166
33167 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33168
33169   return Dali::Actor::Property::OPACITY;
33170 }
33171
33172 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33173
33174   return Dali::Actor::Property::SCREEN_POSITION;
33175 }
33176
33177 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33178
33179   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33180 }
33181
33182 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33183   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33184 }
33185
33186 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33187   return Dali::Actor::Property::LAYOUT_DIRECTION;
33188 }
33189
33190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33191   void * jresult ;
33192   Dali::Actor::Property *result = 0 ;
33193
33194   {
33195     try {
33196       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33197     } catch (std::out_of_range& e) {
33198       {
33199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33200       };
33201     } catch (std::exception& e) {
33202       {
33203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33204       };
33205     } catch (Dali::DaliException e) {
33206       {
33207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33208       };
33209     } catch (...) {
33210       {
33211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33212       };
33213     }
33214   }
33215
33216   jresult = (void *)result;
33217   return jresult;
33218 }
33219
33220
33221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33222   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33223
33224   arg1 = (Dali::Actor::Property *)jarg1;
33225   {
33226     try {
33227       delete arg1;
33228     } catch (std::out_of_range& e) {
33229       {
33230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33231       };
33232     } catch (std::exception& e) {
33233       {
33234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33235       };
33236     } catch (Dali::DaliException e) {
33237       {
33238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33239       };
33240     } catch (...) {
33241       {
33242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33243       };
33244     }
33245   }
33246
33247 }
33248
33249
33250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33251   void * jresult ;
33252   Dali::Actor *result = 0 ;
33253
33254   {
33255     try {
33256       result = (Dali::Actor *)new Dali::Actor();
33257     } catch (std::out_of_range& e) {
33258       {
33259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33260       };
33261     } catch (std::exception& e) {
33262       {
33263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33264       };
33265     } catch (Dali::DaliException e) {
33266       {
33267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33268       };
33269     } catch (...) {
33270       {
33271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33272       };
33273     }
33274   }
33275
33276   jresult = (void *)result;
33277   return jresult;
33278 }
33279
33280
33281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33282   void * jresult ;
33283   Dali::Actor result;
33284
33285   {
33286     try {
33287       result = Dali::Actor::New();
33288     } catch (std::out_of_range& e) {
33289       {
33290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33291       };
33292     } catch (std::exception& e) {
33293       {
33294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33295       };
33296     } catch (Dali::DaliException e) {
33297       {
33298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33299       };
33300     } catch (...) {
33301       {
33302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33303       };
33304     }
33305   }
33306
33307   jresult = new Dali::Actor((const Dali::Actor &)result);
33308   return jresult;
33309 }
33310
33311
33312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33313   void * jresult ;
33314   Dali::BaseHandle arg1 ;
33315   Dali::BaseHandle *argp1 ;
33316   Dali::Actor result;
33317
33318   argp1 = (Dali::BaseHandle *)jarg1;
33319   if (!argp1) {
33320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33321     return 0;
33322   }
33323   arg1 = *argp1;
33324   {
33325     try {
33326       result = Dali::Actor::DownCast(arg1);
33327     } catch (std::out_of_range& e) {
33328       {
33329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33330       };
33331     } catch (std::exception& e) {
33332       {
33333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33334       };
33335     } catch (Dali::DaliException e) {
33336       {
33337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33338       };
33339     } catch (...) {
33340       {
33341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33342       };
33343     }
33344   }
33345
33346   jresult = new Dali::Actor((const Dali::Actor &)result);
33347   return jresult;
33348 }
33349
33350
33351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33352   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33353
33354   arg1 = (Dali::Actor *)jarg1;
33355   {
33356     try {
33357       delete arg1;
33358     } catch (std::out_of_range& e) {
33359       {
33360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33361       };
33362     } catch (std::exception& e) {
33363       {
33364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33365       };
33366     } catch (Dali::DaliException e) {
33367       {
33368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33369       };
33370     } catch (...) {
33371       {
33372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33373       };
33374     }
33375   }
33376
33377 }
33378
33379
33380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33381   void * jresult ;
33382   Dali::Actor *arg1 = 0 ;
33383   Dali::Actor *result = 0 ;
33384
33385   arg1 = (Dali::Actor *)jarg1;
33386   if (!arg1) {
33387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33388     return 0;
33389   }
33390   {
33391     try {
33392       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33393     } catch (std::out_of_range& e) {
33394       {
33395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33396       };
33397     } catch (std::exception& e) {
33398       {
33399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33400       };
33401     } catch (Dali::DaliException e) {
33402       {
33403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33404       };
33405     } catch (...) {
33406       {
33407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33408       };
33409     }
33410   }
33411
33412   jresult = (void *)result;
33413   return jresult;
33414 }
33415
33416
33417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33418   void * jresult ;
33419   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33420   Dali::Actor *arg2 = 0 ;
33421   Dali::Actor *result = 0 ;
33422
33423   arg1 = (Dali::Actor *)jarg1;
33424   arg2 = (Dali::Actor *)jarg2;
33425   if (!arg2) {
33426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33427     return 0;
33428   }
33429   {
33430     try {
33431       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33432     } catch (std::out_of_range& e) {
33433       {
33434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33435       };
33436     } catch (std::exception& e) {
33437       {
33438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33439       };
33440     } catch (Dali::DaliException e) {
33441       {
33442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33443       };
33444     } catch (...) {
33445       {
33446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33447       };
33448     }
33449   }
33450
33451   jresult = (void *)result;
33452   return jresult;
33453 }
33454
33455
33456 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33457   char * jresult ;
33458   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33459   std::string *result = 0 ;
33460
33461   arg1 = (Dali::Actor *)jarg1;
33462   {
33463     try {
33464       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33465       result = (std::string *) &name;
33466     } catch (std::out_of_range& e) {
33467       {
33468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33469       };
33470     } catch (std::exception& e) {
33471       {
33472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33473       };
33474     } catch (Dali::DaliException e) {
33475       {
33476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33477       };
33478     } catch (...) {
33479       {
33480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33481       };
33482     }
33483   }
33484
33485   jresult = SWIG_csharp_string_callback(result->c_str());
33486   return jresult;
33487 }
33488
33489
33490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33491   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33492   std::string *arg2 = 0 ;
33493
33494   arg1 = (Dali::Actor *)jarg1;
33495   if (!jarg2) {
33496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33497     return ;
33498   }
33499   std::string arg2_str(jarg2);
33500   arg2 = &arg2_str;
33501   {
33502     try {
33503       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33504     } catch (std::out_of_range& e) {
33505       {
33506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33507       };
33508     } catch (std::exception& e) {
33509       {
33510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33511       };
33512     } catch (Dali::DaliException e) {
33513       {
33514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33515       };
33516     } catch (...) {
33517       {
33518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33519       };
33520     }
33521   }
33522
33523
33524   //argout typemap for const std::string&
33525
33526 }
33527
33528
33529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33530   unsigned int jresult ;
33531   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33532   unsigned int result;
33533
33534   arg1 = (Dali::Actor *)jarg1;
33535
33536   if(!arg1) {
33537     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33538     return -1;
33539   }
33540
33541   {
33542     try {
33543       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
33544     } catch (std::out_of_range& e) {
33545       {
33546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33547       };
33548     } catch (std::exception& e) {
33549       {
33550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33551       };
33552     } catch (Dali::DaliException e) {
33553       {
33554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33555       };
33556     } catch (...) {
33557       {
33558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33559       };
33560     }
33561   }
33562
33563   jresult = result;
33564   return jresult;
33565 }
33566
33567
33568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33569   unsigned int jresult ;
33570   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33571   bool result;
33572
33573   arg1 = (Dali::Actor *)jarg1;
33574   {
33575     try {
33576       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
33577     } catch (std::out_of_range& e) {
33578       {
33579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33580       };
33581     } catch (std::exception& e) {
33582       {
33583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33584       };
33585     } catch (Dali::DaliException e) {
33586       {
33587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33588       };
33589     } catch (...) {
33590       {
33591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33592       };
33593     }
33594   }
33595
33596   jresult = result;
33597   return jresult;
33598 }
33599
33600
33601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33602   unsigned int jresult ;
33603   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33604   bool result;
33605
33606   arg1 = (Dali::Actor *)jarg1;
33607   {
33608     try {
33609       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
33610     } catch (std::out_of_range& e) {
33611       {
33612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33613       };
33614     } catch (std::exception& e) {
33615       {
33616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33617       };
33618     } catch (Dali::DaliException e) {
33619       {
33620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33621       };
33622     } catch (...) {
33623       {
33624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33625       };
33626     }
33627   }
33628
33629   jresult = result;
33630   return jresult;
33631 }
33632
33633
33634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33635   unsigned int jresult ;
33636   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33637   bool result;
33638
33639   arg1 = (Dali::Actor *)jarg1;
33640   {
33641     try {
33642       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
33643     } catch (std::out_of_range& e) {
33644       {
33645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33646       };
33647     } catch (std::exception& e) {
33648       {
33649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33650       };
33651     } catch (Dali::DaliException e) {
33652       {
33653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33654       };
33655     } catch (...) {
33656       {
33657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33658       };
33659     }
33660   }
33661
33662   jresult = result;
33663   return jresult;
33664 }
33665
33666
33667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33668   void * jresult ;
33669   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33670   Dali::Layer result;
33671
33672   arg1 = (Dali::Actor *)jarg1;
33673   {
33674     try {
33675       result = (arg1)->GetLayer();
33676     } catch (std::out_of_range& e) {
33677       {
33678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33679       };
33680     } catch (std::exception& e) {
33681       {
33682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33683       };
33684     } catch (Dali::DaliException e) {
33685       {
33686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33687       };
33688     } catch (...) {
33689       {
33690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33691       };
33692     }
33693   }
33694
33695   jresult = new Dali::Layer((const Dali::Layer &)result);
33696   return jresult;
33697 }
33698
33699
33700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33701   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33702   Dali::Actor arg2 ;
33703   Dali::Actor *argp2 ;
33704
33705   arg1 = (Dali::Actor *)jarg1;
33706   argp2 = (Dali::Actor *)jarg2;
33707   if (!argp2) {
33708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33709     return ;
33710   }
33711   arg2 = *argp2;
33712   {
33713     try {
33714       (arg1)->Add(arg2);
33715     } catch (std::out_of_range& e) {
33716       {
33717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33718       };
33719     } catch (std::exception& e) {
33720       {
33721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33722       };
33723     } catch (Dali::DaliException e) {
33724       {
33725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33726       };
33727     } catch (...) {
33728       {
33729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33730       };
33731     }
33732   }
33733
33734 }
33735
33736
33737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33738   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33739   Dali::Actor arg2 ;
33740   Dali::Actor *argp2 ;
33741
33742   arg1 = (Dali::Actor *)jarg1;
33743   argp2 = (Dali::Actor *)jarg2;
33744   if (!argp2) {
33745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33746     return ;
33747   }
33748   arg2 = *argp2;
33749   {
33750     try {
33751       (arg1)->Remove(arg2);
33752     } catch (std::out_of_range& e) {
33753       {
33754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33755       };
33756     } catch (std::exception& e) {
33757       {
33758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33759       };
33760     } catch (Dali::DaliException e) {
33761       {
33762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33763       };
33764     } catch (...) {
33765       {
33766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33767       };
33768     }
33769   }
33770
33771 }
33772
33773
33774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33775   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33776
33777   arg1 = (Dali::Actor *)jarg1;
33778   {
33779     try {
33780       (arg1)->Unparent();
33781     } catch (std::out_of_range& e) {
33782       {
33783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33784       };
33785     } catch (std::exception& e) {
33786       {
33787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33788       };
33789     } catch (Dali::DaliException e) {
33790       {
33791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33792       };
33793     } catch (...) {
33794       {
33795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33796       };
33797     }
33798   }
33799
33800 }
33801
33802
33803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33804   unsigned int jresult ;
33805   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33806   unsigned int result;
33807
33808   arg1 = (Dali::Actor *)jarg1;
33809   {
33810     try {
33811       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33812     } catch (std::out_of_range& e) {
33813       {
33814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33815       };
33816     } catch (std::exception& e) {
33817       {
33818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33819       };
33820     } catch (Dali::DaliException e) {
33821       {
33822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33823       };
33824     } catch (...) {
33825       {
33826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33827       };
33828     }
33829   }
33830
33831   jresult = result;
33832   return jresult;
33833 }
33834
33835
33836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33837   void * jresult ;
33838   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33839   unsigned int arg2 ;
33840   Dali::Actor result;
33841
33842   arg1 = (Dali::Actor *)jarg1;
33843   arg2 = (unsigned int)jarg2;
33844   {
33845     try {
33846       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
33847     } catch (std::out_of_range& e) {
33848       {
33849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33850       };
33851     } catch (std::exception& e) {
33852       {
33853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33854       };
33855     } catch (Dali::DaliException e) {
33856       {
33857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33858       };
33859     } catch (...) {
33860       {
33861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33862       };
33863     }
33864   }
33865
33866   jresult = new Dali::Actor((const Dali::Actor &)result);
33867   return jresult;
33868 }
33869
33870
33871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
33872   void * jresult ;
33873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33874   std::string *arg2 = 0 ;
33875   Dali::Actor result;
33876
33877   arg1 = (Dali::Actor *)jarg1;
33878   if (!jarg2) {
33879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33880     return 0;
33881   }
33882   std::string arg2_str(jarg2);
33883   arg2 = &arg2_str;
33884   {
33885     try {
33886       result = (arg1)->FindChildByName((std::string const &)*arg2);
33887     } catch (std::out_of_range& e) {
33888       {
33889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33890       };
33891     } catch (std::exception& e) {
33892       {
33893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33894       };
33895     } catch (Dali::DaliException e) {
33896       {
33897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33898       };
33899     } catch (...) {
33900       {
33901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33902       };
33903     }
33904   }
33905
33906   jresult = new Dali::Actor((const Dali::Actor &)result);
33907
33908   //argout typemap for const std::string&
33909
33910   return jresult;
33911 }
33912
33913
33914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
33915   void * jresult ;
33916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33917   unsigned int arg2 ;
33918   Dali::Actor result;
33919
33920   arg1 = (Dali::Actor *)jarg1;
33921   arg2 = (unsigned int)jarg2;
33922   {
33923     try {
33924       result = (arg1)->FindChildById(arg2);
33925     } catch (std::out_of_range& e) {
33926       {
33927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33928       };
33929     } catch (std::exception& e) {
33930       {
33931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33932       };
33933     } catch (Dali::DaliException e) {
33934       {
33935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33936       };
33937     } catch (...) {
33938       {
33939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33940       };
33941     }
33942   }
33943
33944   jresult = new Dali::Actor((const Dali::Actor &)result);
33945   return jresult;
33946 }
33947
33948
33949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
33950   void * jresult ;
33951   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33952   Dali::Actor result;
33953
33954   arg1 = (Dali::Actor *)jarg1;
33955   {
33956     try {
33957       result = ((Dali::Actor const *)arg1)->GetParent();
33958     } catch (std::out_of_range& e) {
33959       {
33960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33961       };
33962     } catch (std::exception& e) {
33963       {
33964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33965       };
33966     } catch (Dali::DaliException e) {
33967       {
33968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33969       };
33970     } catch (...) {
33971       {
33972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33973       };
33974     }
33975   }
33976
33977   jresult = new Dali::Actor((const Dali::Actor &)result);
33978   return jresult;
33979 }
33980
33981
33982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
33983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33984   Dali::Vector3 *arg2 = 0 ;
33985
33986   arg1 = (Dali::Actor *)jarg1;
33987   arg2 = (Dali::Vector3 *)jarg2;
33988   if (!arg2) {
33989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33990     return ;
33991   }
33992   {
33993     try {
33994       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
33995     } catch (std::out_of_range& e) {
33996       {
33997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33998       };
33999     } catch (std::exception& e) {
34000       {
34001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34002       };
34003     } catch (Dali::DaliException e) {
34004       {
34005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34006       };
34007     } catch (...) {
34008       {
34009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34010       };
34011     }
34012   }
34013
34014 }
34015
34016
34017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34018   void * jresult ;
34019   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34020   Dali::Vector3 result;
34021
34022   arg1 = (Dali::Actor *)jarg1;
34023   {
34024     try {
34025       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34026     } catch (std::out_of_range& e) {
34027       {
34028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34029       };
34030     } catch (std::exception& e) {
34031       {
34032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34033       };
34034     } catch (Dali::DaliException e) {
34035       {
34036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34037       };
34038     } catch (...) {
34039       {
34040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34041       };
34042     }
34043   }
34044
34045   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34046   return jresult;
34047 }
34048
34049
34050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34051   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34052   Dali::Vector3 *arg2 = 0 ;
34053
34054   arg1 = (Dali::Actor *)jarg1;
34055   arg2 = (Dali::Vector3 *)jarg2;
34056   if (!arg2) {
34057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34058     return ;
34059   }
34060   {
34061     try {
34062       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34063     } catch (std::out_of_range& e) {
34064       {
34065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34066       };
34067     } catch (std::exception& e) {
34068       {
34069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34070       };
34071     } catch (Dali::DaliException e) {
34072       {
34073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34074       };
34075     } catch (...) {
34076       {
34077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34078       };
34079     }
34080   }
34081
34082 }
34083
34084
34085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34086   void * jresult ;
34087   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34088   Dali::Vector3 result;
34089
34090   arg1 = (Dali::Actor *)jarg1;
34091   {
34092     try {
34093       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34094     } catch (std::out_of_range& e) {
34095       {
34096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34097       };
34098     } catch (std::exception& e) {
34099       {
34100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34101       };
34102     } catch (Dali::DaliException e) {
34103       {
34104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34105       };
34106     } catch (...) {
34107       {
34108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34109       };
34110     }
34111   }
34112
34113   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34114   return jresult;
34115 }
34116
34117
34118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34119   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34120   float arg2 ;
34121   float arg3 ;
34122
34123   arg1 = (Dali::Actor *)jarg1;
34124   arg2 = (float)jarg2;
34125   arg3 = (float)jarg3;
34126   {
34127     try {
34128       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34129     } catch (std::out_of_range& e) {
34130       {
34131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34132       };
34133     } catch (std::exception& e) {
34134       {
34135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34136       };
34137     } catch (Dali::DaliException e) {
34138       {
34139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34140       };
34141     } catch (...) {
34142       {
34143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34144       };
34145     }
34146   }
34147
34148 }
34149
34150
34151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34152   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34153   float arg2 ;
34154   float arg3 ;
34155   float arg4 ;
34156
34157   arg1 = (Dali::Actor *)jarg1;
34158   arg2 = (float)jarg2;
34159   arg3 = (float)jarg3;
34160   arg4 = (float)jarg4;
34161   {
34162     try {
34163       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34164     } catch (std::out_of_range& e) {
34165       {
34166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34167       };
34168     } catch (std::exception& e) {
34169       {
34170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34171       };
34172     } catch (Dali::DaliException e) {
34173       {
34174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34175       };
34176     } catch (...) {
34177       {
34178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34179       };
34180     }
34181   }
34182
34183 }
34184
34185
34186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34187   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34188   Dali::Vector2 *arg2 = 0 ;
34189
34190   arg1 = (Dali::Actor *)jarg1;
34191   arg2 = (Dali::Vector2 *)jarg2;
34192   if (!arg2) {
34193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34194     return ;
34195   }
34196   {
34197     try {
34198       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34199     } catch (std::out_of_range& e) {
34200       {
34201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34202       };
34203     } catch (std::exception& e) {
34204       {
34205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34206       };
34207     } catch (Dali::DaliException e) {
34208       {
34209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34210       };
34211     } catch (...) {
34212       {
34213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34214       };
34215     }
34216   }
34217
34218 }
34219
34220
34221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34222   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34223   Dali::Vector3 *arg2 = 0 ;
34224
34225   arg1 = (Dali::Actor *)jarg1;
34226   arg2 = (Dali::Vector3 *)jarg2;
34227   if (!arg2) {
34228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34229     return ;
34230   }
34231   {
34232     try {
34233       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34234     } catch (std::out_of_range& e) {
34235       {
34236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34237       };
34238     } catch (std::exception& e) {
34239       {
34240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34241       };
34242     } catch (Dali::DaliException e) {
34243       {
34244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34245       };
34246     } catch (...) {
34247       {
34248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34249       };
34250     }
34251   }
34252
34253 }
34254
34255
34256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34257   void * jresult ;
34258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34259   Dali::Vector3 result;
34260
34261   arg1 = (Dali::Actor *)jarg1;
34262   {
34263     try {
34264       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34265     } catch (std::out_of_range& e) {
34266       {
34267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34268       };
34269     } catch (std::exception& e) {
34270       {
34271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34272       };
34273     } catch (Dali::DaliException e) {
34274       {
34275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34276       };
34277     } catch (...) {
34278       {
34279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34280       };
34281     }
34282   }
34283
34284   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34285   return jresult;
34286 }
34287
34288
34289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34290   void * jresult ;
34291   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34292   Dali::Vector3 result;
34293
34294   arg1 = (Dali::Actor *)jarg1;
34295   {
34296     try {
34297       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34298     } catch (std::out_of_range& e) {
34299       {
34300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34301       };
34302     } catch (std::exception& e) {
34303       {
34304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34305       };
34306     } catch (Dali::DaliException e) {
34307       {
34308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34309       };
34310     } catch (...) {
34311       {
34312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34313       };
34314     }
34315   }
34316
34317   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34318   return jresult;
34319 }
34320
34321
34322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34323   void * jresult ;
34324   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34325   Dali::Vector3 result;
34326
34327   arg1 = (Dali::Actor *)jarg1;
34328   {
34329     try {
34330       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34331     } catch (std::out_of_range& e) {
34332       {
34333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34334       };
34335     } catch (std::exception& e) {
34336       {
34337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34338       };
34339     } catch (Dali::DaliException e) {
34340       {
34341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34342       };
34343     } catch (...) {
34344       {
34345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34346       };
34347     }
34348   }
34349
34350   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34351   return jresult;
34352 }
34353
34354
34355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34357   float arg2 ;
34358   float arg3 ;
34359
34360   arg1 = (Dali::Actor *)jarg1;
34361   arg2 = (float)jarg2;
34362   arg3 = (float)jarg3;
34363   {
34364     try {
34365       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34366     } catch (std::out_of_range& e) {
34367       {
34368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34369       };
34370     } catch (std::exception& e) {
34371       {
34372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34373       };
34374     } catch (Dali::DaliException e) {
34375       {
34376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34377       };
34378     } catch (...) {
34379       {
34380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34381       };
34382     }
34383   }
34384
34385 }
34386
34387
34388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34390   float arg2 ;
34391   float arg3 ;
34392   float arg4 ;
34393
34394   arg1 = (Dali::Actor *)jarg1;
34395   arg2 = (float)jarg2;
34396   arg3 = (float)jarg3;
34397   arg4 = (float)jarg4;
34398   {
34399     try {
34400       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34401     } catch (std::out_of_range& e) {
34402       {
34403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34404       };
34405     } catch (std::exception& e) {
34406       {
34407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34408       };
34409     } catch (Dali::DaliException e) {
34410       {
34411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34412       };
34413     } catch (...) {
34414       {
34415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34416       };
34417     }
34418   }
34419
34420 }
34421
34422
34423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34424   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34425   Dali::Vector3 *arg2 = 0 ;
34426
34427   arg1 = (Dali::Actor *)jarg1;
34428   arg2 = (Dali::Vector3 *)jarg2;
34429   if (!arg2) {
34430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34431     return ;
34432   }
34433   {
34434     try {
34435       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34436     } catch (std::out_of_range& e) {
34437       {
34438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34439       };
34440     } catch (std::exception& e) {
34441       {
34442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34443       };
34444     } catch (Dali::DaliException e) {
34445       {
34446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34447       };
34448     } catch (...) {
34449       {
34450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34451       };
34452     }
34453   }
34454
34455 }
34456
34457
34458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34459   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34460   float arg2 ;
34461
34462   arg1 = (Dali::Actor *)jarg1;
34463   arg2 = (float)jarg2;
34464   {
34465     try {
34466       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34467     } catch (std::out_of_range& e) {
34468       {
34469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34470       };
34471     } catch (std::exception& e) {
34472       {
34473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34474       };
34475     } catch (Dali::DaliException e) {
34476       {
34477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34478       };
34479     } catch (...) {
34480       {
34481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34482       };
34483     }
34484   }
34485
34486 }
34487
34488
34489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34490   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34491   float arg2 ;
34492
34493   arg1 = (Dali::Actor *)jarg1;
34494   arg2 = (float)jarg2;
34495   {
34496     try {
34497       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34498     } catch (std::out_of_range& e) {
34499       {
34500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34501       };
34502     } catch (std::exception& e) {
34503       {
34504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34505       };
34506     } catch (Dali::DaliException e) {
34507       {
34508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34509       };
34510     } catch (...) {
34511       {
34512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34513       };
34514     }
34515   }
34516
34517 }
34518
34519
34520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34521   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34522   float arg2 ;
34523
34524   arg1 = (Dali::Actor *)jarg1;
34525   arg2 = (float)jarg2;
34526   {
34527     try {
34528       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34529     } catch (std::out_of_range& e) {
34530       {
34531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34532       };
34533     } catch (std::exception& e) {
34534       {
34535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34536       };
34537     } catch (Dali::DaliException e) {
34538       {
34539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34540       };
34541     } catch (...) {
34542       {
34543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34544       };
34545     }
34546   }
34547
34548 }
34549
34550
34551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34552   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34553   Dali::Vector3 *arg2 = 0 ;
34554
34555   arg1 = (Dali::Actor *)jarg1;
34556   arg2 = (Dali::Vector3 *)jarg2;
34557   if (!arg2) {
34558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34559     return ;
34560   }
34561   {
34562     try {
34563       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34564     } catch (std::out_of_range& e) {
34565       {
34566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34567       };
34568     } catch (std::exception& e) {
34569       {
34570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34571       };
34572     } catch (Dali::DaliException e) {
34573       {
34574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34575       };
34576     } catch (...) {
34577       {
34578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34579       };
34580     }
34581   }
34582
34583 }
34584
34585
34586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34587   void * jresult ;
34588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34589   Dali::Vector3 result;
34590
34591   arg1 = (Dali::Actor *)jarg1;
34592   {
34593     try {
34594       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34595     } catch (std::out_of_range& e) {
34596       {
34597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34598       };
34599     } catch (std::exception& e) {
34600       {
34601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34602       };
34603     } catch (Dali::DaliException e) {
34604       {
34605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34606       };
34607     } catch (...) {
34608       {
34609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34610       };
34611     }
34612   }
34613
34614   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34615   return jresult;
34616 }
34617
34618
34619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34620   void * jresult ;
34621   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34622   Dali::Vector3 result;
34623
34624   arg1 = (Dali::Actor *)jarg1;
34625   {
34626     try {
34627       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34628     } catch (std::out_of_range& e) {
34629       {
34630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34631       };
34632     } catch (std::exception& e) {
34633       {
34634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34635       };
34636     } catch (Dali::DaliException e) {
34637       {
34638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34639       };
34640     } catch (...) {
34641       {
34642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34643       };
34644     }
34645   }
34646
34647   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34648   return jresult;
34649 }
34650
34651
34652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34654   bool arg2 ;
34655
34656   arg1 = (Dali::Actor *)jarg1;
34657   arg2 = jarg2 ? true : false;
34658   {
34659     try {
34660       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
34661     } catch (std::out_of_range& e) {
34662       {
34663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34664       };
34665     } catch (std::exception& e) {
34666       {
34667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34668       };
34669     } catch (Dali::DaliException e) {
34670       {
34671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34672       };
34673     } catch (...) {
34674       {
34675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34676       };
34677     }
34678   }
34679
34680 }
34681
34682
34683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34684   unsigned int jresult ;
34685   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34686   bool result;
34687
34688   arg1 = (Dali::Actor *)jarg1;
34689   {
34690     try {
34691       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
34692     } catch (std::out_of_range& e) {
34693       {
34694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34695       };
34696     } catch (std::exception& e) {
34697       {
34698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34699       };
34700     } catch (Dali::DaliException e) {
34701       {
34702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34703       };
34704     } catch (...) {
34705       {
34706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34707       };
34708     }
34709   }
34710
34711   jresult = result;
34712   return jresult;
34713 }
34714
34715
34716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34718   Dali::Degree *arg2 = 0 ;
34719   Dali::Vector3 *arg3 = 0 ;
34720
34721   arg1 = (Dali::Actor *)jarg1;
34722   arg2 = (Dali::Degree *)jarg2;
34723   if (!arg2) {
34724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34725     return ;
34726   }
34727   arg3 = (Dali::Vector3 *)jarg3;
34728   if (!arg3) {
34729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34730     return ;
34731   }
34732   {
34733     try {
34734       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34735     } catch (std::out_of_range& e) {
34736       {
34737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34738       };
34739     } catch (std::exception& e) {
34740       {
34741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34742       };
34743     } catch (Dali::DaliException e) {
34744       {
34745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34746       };
34747     } catch (...) {
34748       {
34749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34750       };
34751     }
34752   }
34753
34754 }
34755
34756
34757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34758   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34759   Dali::Radian *arg2 = 0 ;
34760   Dali::Vector3 *arg3 = 0 ;
34761
34762   arg1 = (Dali::Actor *)jarg1;
34763   arg2 = (Dali::Radian *)jarg2;
34764   if (!arg2) {
34765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34766     return ;
34767   }
34768   arg3 = (Dali::Vector3 *)jarg3;
34769   if (!arg3) {
34770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34771     return ;
34772   }
34773   {
34774     try {
34775       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34776     } catch (std::out_of_range& e) {
34777       {
34778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34779       };
34780     } catch (std::exception& e) {
34781       {
34782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34783       };
34784     } catch (Dali::DaliException e) {
34785       {
34786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34787       };
34788     } catch (...) {
34789       {
34790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34791       };
34792     }
34793   }
34794
34795 }
34796
34797
34798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34799   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34800   Dali::Quaternion *arg2 = 0 ;
34801
34802   arg1 = (Dali::Actor *)jarg1;
34803   arg2 = (Dali::Quaternion *)jarg2;
34804   if (!arg2) {
34805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34806     return ;
34807   }
34808   {
34809     try {
34810       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
34811     } catch (std::out_of_range& e) {
34812       {
34813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34814       };
34815     } catch (std::exception& e) {
34816       {
34817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34818       };
34819     } catch (Dali::DaliException e) {
34820       {
34821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34822       };
34823     } catch (...) {
34824       {
34825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34826       };
34827     }
34828   }
34829
34830 }
34831
34832
34833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34835   Dali::Degree *arg2 = 0 ;
34836   Dali::Vector3 *arg3 = 0 ;
34837
34838   arg1 = (Dali::Actor *)jarg1;
34839   arg2 = (Dali::Degree *)jarg2;
34840   if (!arg2) {
34841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34842     return ;
34843   }
34844   arg3 = (Dali::Vector3 *)jarg3;
34845   if (!arg3) {
34846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34847     return ;
34848   }
34849   {
34850     try {
34851       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34852     } catch (std::out_of_range& e) {
34853       {
34854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34855       };
34856     } catch (std::exception& e) {
34857       {
34858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34859       };
34860     } catch (Dali::DaliException e) {
34861       {
34862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34863       };
34864     } catch (...) {
34865       {
34866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34867       };
34868     }
34869   }
34870
34871 }
34872
34873
34874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34875   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34876   Dali::Radian *arg2 = 0 ;
34877   Dali::Vector3 *arg3 = 0 ;
34878
34879   arg1 = (Dali::Actor *)jarg1;
34880   arg2 = (Dali::Radian *)jarg2;
34881   if (!arg2) {
34882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34883     return ;
34884   }
34885   arg3 = (Dali::Vector3 *)jarg3;
34886   if (!arg3) {
34887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34888     return ;
34889   }
34890   {
34891     try {
34892       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34893     } catch (std::out_of_range& e) {
34894       {
34895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34896       };
34897     } catch (std::exception& e) {
34898       {
34899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34900       };
34901     } catch (Dali::DaliException e) {
34902       {
34903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34904       };
34905     } catch (...) {
34906       {
34907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34908       };
34909     }
34910   }
34911
34912 }
34913
34914
34915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
34916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34917   Dali::Quaternion *arg2 = 0 ;
34918
34919   arg1 = (Dali::Actor *)jarg1;
34920   arg2 = (Dali::Quaternion *)jarg2;
34921   if (!arg2) {
34922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34923     return ;
34924   }
34925   {
34926     try {
34927       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
34928     } catch (std::out_of_range& e) {
34929       {
34930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34931       };
34932     } catch (std::exception& e) {
34933       {
34934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34935       };
34936     } catch (Dali::DaliException e) {
34937       {
34938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34939       };
34940     } catch (...) {
34941       {
34942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34943       };
34944     }
34945   }
34946
34947 }
34948
34949
34950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
34951   void * jresult ;
34952   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34953   Dali::Quaternion result;
34954
34955   arg1 = (Dali::Actor *)jarg1;
34956   {
34957     try {
34958       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
34959     } catch (std::out_of_range& e) {
34960       {
34961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34962       };
34963     } catch (std::exception& e) {
34964       {
34965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34966       };
34967     } catch (Dali::DaliException e) {
34968       {
34969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34970       };
34971     } catch (...) {
34972       {
34973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34974       };
34975     }
34976   }
34977
34978   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
34979   return jresult;
34980 }
34981
34982
34983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
34984   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34985   bool arg2 ;
34986
34987   arg1 = (Dali::Actor *)jarg1;
34988   arg2 = jarg2 ? true : false;
34989   {
34990     try {
34991       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
34992     } catch (std::out_of_range& e) {
34993       {
34994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34995       };
34996     } catch (std::exception& e) {
34997       {
34998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34999       };
35000     } catch (Dali::DaliException e) {
35001       {
35002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35003       };
35004     } catch (...) {
35005       {
35006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35007       };
35008     }
35009   }
35010
35011 }
35012
35013
35014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35015   unsigned int jresult ;
35016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35017   bool result;
35018
35019   arg1 = (Dali::Actor *)jarg1;
35020   {
35021     try {
35022       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35023     } catch (std::out_of_range& e) {
35024       {
35025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35026       };
35027     } catch (std::exception& e) {
35028       {
35029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35030       };
35031     } catch (Dali::DaliException e) {
35032       {
35033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35034       };
35035     } catch (...) {
35036       {
35037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35038       };
35039     }
35040   }
35041
35042   jresult = result;
35043   return jresult;
35044 }
35045
35046
35047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35048   void * jresult ;
35049   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35050   Dali::Quaternion result;
35051
35052   arg1 = (Dali::Actor *)jarg1;
35053   {
35054     try {
35055       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35056     } catch (std::out_of_range& e) {
35057       {
35058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35059       };
35060     } catch (std::exception& e) {
35061       {
35062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35063       };
35064     } catch (Dali::DaliException e) {
35065       {
35066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35067       };
35068     } catch (...) {
35069       {
35070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35071       };
35072     }
35073   }
35074
35075   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35076   return jresult;
35077 }
35078
35079
35080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35081   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35082   float arg2 ;
35083
35084   arg1 = (Dali::Actor *)jarg1;
35085   arg2 = (float)jarg2;
35086   {
35087     try {
35088       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35089     } catch (std::out_of_range& e) {
35090       {
35091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35092       };
35093     } catch (std::exception& e) {
35094       {
35095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35096       };
35097     } catch (Dali::DaliException e) {
35098       {
35099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35100       };
35101     } catch (...) {
35102       {
35103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35104       };
35105     }
35106   }
35107
35108 }
35109
35110
35111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35113   float arg2 ;
35114   float arg3 ;
35115   float arg4 ;
35116
35117   arg1 = (Dali::Actor *)jarg1;
35118   arg2 = (float)jarg2;
35119   arg3 = (float)jarg3;
35120   arg4 = (float)jarg4;
35121   {
35122     try {
35123       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35124     } catch (std::out_of_range& e) {
35125       {
35126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35127       };
35128     } catch (std::exception& e) {
35129       {
35130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35131       };
35132     } catch (Dali::DaliException e) {
35133       {
35134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35135       };
35136     } catch (...) {
35137       {
35138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35139       };
35140     }
35141   }
35142
35143 }
35144
35145
35146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35147   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35148   Dali::Vector3 *arg2 = 0 ;
35149
35150   arg1 = (Dali::Actor *)jarg1;
35151   arg2 = (Dali::Vector3 *)jarg2;
35152   if (!arg2) {
35153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35154     return ;
35155   }
35156   {
35157     try {
35158       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35159     } catch (std::out_of_range& e) {
35160       {
35161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35162       };
35163     } catch (std::exception& e) {
35164       {
35165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35166       };
35167     } catch (Dali::DaliException e) {
35168       {
35169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35170       };
35171     } catch (...) {
35172       {
35173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35174       };
35175     }
35176   }
35177
35178 }
35179
35180
35181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35182   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35183   Dali::Vector3 *arg2 = 0 ;
35184
35185   arg1 = (Dali::Actor *)jarg1;
35186   arg2 = (Dali::Vector3 *)jarg2;
35187   if (!arg2) {
35188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35189     return ;
35190   }
35191   {
35192     try {
35193       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35194     } catch (std::out_of_range& e) {
35195       {
35196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35197       };
35198     } catch (std::exception& e) {
35199       {
35200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35201       };
35202     } catch (Dali::DaliException e) {
35203       {
35204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35205       };
35206     } catch (...) {
35207       {
35208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35209       };
35210     }
35211   }
35212
35213 }
35214
35215
35216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35217   void * jresult ;
35218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35219   Dali::Vector3 result;
35220
35221   arg1 = (Dali::Actor *)jarg1;
35222   {
35223     try {
35224       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35225     } catch (std::out_of_range& e) {
35226       {
35227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35228       };
35229     } catch (std::exception& e) {
35230       {
35231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35232       };
35233     } catch (Dali::DaliException e) {
35234       {
35235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35236       };
35237     } catch (...) {
35238       {
35239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35240       };
35241     }
35242   }
35243
35244   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35245   return jresult;
35246 }
35247
35248
35249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35250   void * jresult ;
35251   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35252   Dali::Vector3 result;
35253
35254   arg1 = (Dali::Actor *)jarg1;
35255   {
35256     try {
35257       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35258     } catch (std::out_of_range& e) {
35259       {
35260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35261       };
35262     } catch (std::exception& e) {
35263       {
35264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35265       };
35266     } catch (Dali::DaliException e) {
35267       {
35268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35269       };
35270     } catch (...) {
35271       {
35272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35273       };
35274     }
35275   }
35276
35277   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35278   return jresult;
35279 }
35280
35281
35282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35283   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35284   bool arg2 ;
35285
35286   arg1 = (Dali::Actor *)jarg1;
35287   arg2 = jarg2 ? true : false;
35288   {
35289     try {
35290       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35291     } catch (std::out_of_range& e) {
35292       {
35293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35294       };
35295     } catch (std::exception& e) {
35296       {
35297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35298       };
35299     } catch (Dali::DaliException e) {
35300       {
35301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35302       };
35303     } catch (...) {
35304       {
35305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35306       };
35307     }
35308   }
35309
35310 }
35311
35312
35313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35314   unsigned int jresult ;
35315   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35316   bool result;
35317
35318   arg1 = (Dali::Actor *)jarg1;
35319   {
35320     try {
35321       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35322     } catch (std::out_of_range& e) {
35323       {
35324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35325       };
35326     } catch (std::exception& e) {
35327       {
35328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35329       };
35330     } catch (Dali::DaliException e) {
35331       {
35332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35333       };
35334     } catch (...) {
35335       {
35336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35337       };
35338     }
35339   }
35340
35341   jresult = result;
35342   return jresult;
35343 }
35344
35345
35346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35347   void * jresult ;
35348   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35349   Dali::Matrix result;
35350
35351   arg1 = (Dali::Actor *)jarg1;
35352   {
35353     try {
35354       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35355     } catch (std::out_of_range& e) {
35356       {
35357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35358       };
35359     } catch (std::exception& e) {
35360       {
35361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35362       };
35363     } catch (Dali::DaliException e) {
35364       {
35365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35366       };
35367     } catch (...) {
35368       {
35369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35370       };
35371     }
35372   }
35373
35374   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35375   return jresult;
35376 }
35377
35378
35379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35381   bool arg2 ;
35382
35383   arg1 = (Dali::Actor *)jarg1;
35384   arg2 = jarg2 ? true : false;
35385   {
35386     try {
35387       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35388     } catch (std::out_of_range& e) {
35389       {
35390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35391       };
35392     } catch (std::exception& e) {
35393       {
35394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35395       };
35396     } catch (Dali::DaliException e) {
35397       {
35398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35399       };
35400     } catch (...) {
35401       {
35402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35403       };
35404     }
35405   }
35406
35407 }
35408
35409
35410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35411   unsigned int jresult ;
35412   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35413   bool result;
35414
35415   arg1 = (Dali::Actor *)jarg1;
35416   {
35417     try {
35418       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35419     } catch (std::out_of_range& e) {
35420       {
35421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35422       };
35423     } catch (std::exception& e) {
35424       {
35425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35426       };
35427     } catch (Dali::DaliException e) {
35428       {
35429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35430       };
35431     } catch (...) {
35432       {
35433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35434       };
35435     }
35436   }
35437
35438   jresult = result;
35439   return jresult;
35440 }
35441
35442
35443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35444   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35445   float arg2 ;
35446
35447   arg1 = (Dali::Actor *)jarg1;
35448   arg2 = (float)jarg2;
35449   {
35450     try {
35451       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35452     } catch (std::out_of_range& e) {
35453       {
35454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35455       };
35456     } catch (std::exception& e) {
35457       {
35458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35459       };
35460     } catch (Dali::DaliException e) {
35461       {
35462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35463       };
35464     } catch (...) {
35465       {
35466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35467       };
35468     }
35469   }
35470
35471 }
35472
35473
35474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35475   float jresult ;
35476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35477   float result;
35478
35479   arg1 = (Dali::Actor *)jarg1;
35480   {
35481     try {
35482       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35483     } catch (std::out_of_range& e) {
35484       {
35485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35486       };
35487     } catch (std::exception& e) {
35488       {
35489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35490       };
35491     } catch (Dali::DaliException e) {
35492       {
35493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35494       };
35495     } catch (...) {
35496       {
35497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35498       };
35499     }
35500   }
35501
35502   jresult = result;
35503   return jresult;
35504 }
35505
35506
35507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35508   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35509   Dali::Vector4 *arg2 = 0 ;
35510
35511   arg1 = (Dali::Actor *)jarg1;
35512   arg2 = (Dali::Vector4 *)jarg2;
35513   if (!arg2) {
35514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35515     return ;
35516   }
35517   {
35518     try {
35519       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35520     } catch (std::out_of_range& e) {
35521       {
35522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35523       };
35524     } catch (std::exception& e) {
35525       {
35526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35527       };
35528     } catch (Dali::DaliException e) {
35529       {
35530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35531       };
35532     } catch (...) {
35533       {
35534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35535       };
35536     }
35537   }
35538
35539 }
35540
35541
35542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35543   void * jresult ;
35544   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35545   Dali::Vector4 result;
35546
35547   arg1 = (Dali::Actor *)jarg1;
35548   {
35549     try {
35550       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35551     } catch (std::out_of_range& e) {
35552       {
35553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35554       };
35555     } catch (std::exception& e) {
35556       {
35557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35558       };
35559     } catch (Dali::DaliException e) {
35560       {
35561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35562       };
35563     } catch (...) {
35564       {
35565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35566       };
35567     }
35568   }
35569
35570   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35571   return jresult;
35572 }
35573
35574
35575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35576   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35577   Dali::ColorMode arg2 ;
35578
35579   arg1 = (Dali::Actor *)jarg1;
35580   arg2 = (Dali::ColorMode)jarg2;
35581   {
35582     try {
35583       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35584     } catch (std::out_of_range& e) {
35585       {
35586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35587       };
35588     } catch (std::exception& e) {
35589       {
35590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35591       };
35592     } catch (Dali::DaliException e) {
35593       {
35594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35595       };
35596     } catch (...) {
35597       {
35598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35599       };
35600     }
35601   }
35602
35603 }
35604
35605
35606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35607   int jresult ;
35608   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35609   Dali::ColorMode result;
35610
35611   arg1 = (Dali::Actor *)jarg1;
35612   {
35613     try {
35614       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35615     } catch (std::out_of_range& e) {
35616       {
35617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35618       };
35619     } catch (std::exception& e) {
35620       {
35621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35622       };
35623     } catch (Dali::DaliException e) {
35624       {
35625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35626       };
35627     } catch (...) {
35628       {
35629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35630       };
35631     }
35632   }
35633
35634   jresult = (int)result;
35635   return jresult;
35636 }
35637
35638
35639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35640   void * jresult ;
35641   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35642   Dali::Vector4 result;
35643
35644   arg1 = (Dali::Actor *)jarg1;
35645   {
35646     try {
35647       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35648     } catch (std::out_of_range& e) {
35649       {
35650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35651       };
35652     } catch (std::exception& e) {
35653       {
35654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35655       };
35656     } catch (Dali::DaliException e) {
35657       {
35658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35659       };
35660     } catch (...) {
35661       {
35662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35663       };
35664     }
35665   }
35666
35667   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35668   return jresult;
35669 }
35670
35671
35672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35673   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35674   Dali::DrawMode::Type arg2 ;
35675
35676   arg1 = (Dali::Actor *)jarg1;
35677   arg2 = (Dali::DrawMode::Type)jarg2;
35678   {
35679     try {
35680       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35681     } catch (std::out_of_range& e) {
35682       {
35683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35684       };
35685     } catch (std::exception& e) {
35686       {
35687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35688       };
35689     } catch (Dali::DaliException e) {
35690       {
35691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35692       };
35693     } catch (...) {
35694       {
35695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35696       };
35697     }
35698   }
35699
35700 }
35701
35702
35703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35704   int jresult ;
35705   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35706   Dali::DrawMode::Type result;
35707
35708   arg1 = (Dali::Actor *)jarg1;
35709   {
35710     try {
35711       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
35712     } catch (std::out_of_range& e) {
35713       {
35714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35715       };
35716     } catch (std::exception& e) {
35717       {
35718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35719       };
35720     } catch (Dali::DaliException e) {
35721       {
35722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35723       };
35724     } catch (...) {
35725       {
35726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35727       };
35728     }
35729   }
35730
35731   jresult = (int)result;
35732   return jresult;
35733 }
35734
35735
35736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35737   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35738   bool arg2 ;
35739
35740   arg1 = (Dali::Actor *)jarg1;
35741   arg2 = jarg2 ? true : false;
35742   {
35743     try {
35744       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
35745     } catch (std::out_of_range& e) {
35746       {
35747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35748       };
35749     } catch (std::exception& e) {
35750       {
35751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35752       };
35753     } catch (Dali::DaliException e) {
35754       {
35755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35756       };
35757     } catch (...) {
35758       {
35759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35760       };
35761     }
35762   }
35763
35764 }
35765
35766
35767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35768   unsigned int jresult ;
35769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35770   bool result;
35771
35772   arg1 = (Dali::Actor *)jarg1;
35773   {
35774     try {
35775       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
35776     } catch (std::out_of_range& e) {
35777       {
35778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35779       };
35780     } catch (std::exception& e) {
35781       {
35782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35783       };
35784     } catch (Dali::DaliException e) {
35785       {
35786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35787       };
35788     } catch (...) {
35789       {
35790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35791       };
35792     }
35793   }
35794
35795   jresult = result;
35796   return jresult;
35797 }
35798
35799
35800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35801   unsigned int jresult ;
35802   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35803   float *arg2 = 0 ;
35804   float *arg3 = 0 ;
35805   float arg4 ;
35806   float arg5 ;
35807   bool result;
35808
35809   arg1 = (Dali::Actor *)jarg1;
35810   arg2 = (float *)jarg2;
35811   arg3 = (float *)jarg3;
35812   arg4 = (float)jarg4;
35813   arg5 = (float)jarg5;
35814   {
35815     try {
35816       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35817     } catch (std::out_of_range& e) {
35818       {
35819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35820       };
35821     } catch (std::exception& e) {
35822       {
35823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35824       };
35825     } catch (Dali::DaliException e) {
35826       {
35827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35828       };
35829     } catch (...) {
35830       {
35831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35832       };
35833     }
35834   }
35835
35836   jresult = result;
35837   return jresult;
35838 }
35839
35840
35841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35842   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35843   bool arg2 ;
35844
35845   arg1 = (Dali::Actor *)jarg1;
35846   arg2 = jarg2 ? true : false;
35847   {
35848     try {
35849       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
35850     } catch (std::out_of_range& e) {
35851       {
35852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35853       };
35854     } catch (std::exception& e) {
35855       {
35856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35857       };
35858     } catch (Dali::DaliException e) {
35859       {
35860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35861       };
35862     } catch (...) {
35863       {
35864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35865       };
35866     }
35867   }
35868
35869 }
35870
35871
35872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
35873   unsigned int jresult ;
35874   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35875   bool result;
35876
35877   arg1 = (Dali::Actor *)jarg1;
35878   {
35879     try {
35880       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
35881     } catch (std::out_of_range& e) {
35882       {
35883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35884       };
35885     } catch (std::exception& e) {
35886       {
35887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35888       };
35889     } catch (Dali::DaliException e) {
35890       {
35891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35892       };
35893     } catch (...) {
35894       {
35895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35896       };
35897     }
35898   }
35899
35900   jresult = result;
35901   return jresult;
35902 }
35903
35904
35905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
35906   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35907   bool arg2 ;
35908
35909   arg1 = (Dali::Actor *)jarg1;
35910   arg2 = jarg2 ? true : false;
35911   {
35912     try {
35913       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
35914     } catch (std::out_of_range& e) {
35915       {
35916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35917       };
35918     } catch (std::exception& e) {
35919       {
35920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35921       };
35922     } catch (Dali::DaliException e) {
35923       {
35924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35925       };
35926     } catch (...) {
35927       {
35928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35929       };
35930     }
35931   }
35932
35933 }
35934
35935
35936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
35937   unsigned int jresult ;
35938   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35939   bool result;
35940
35941   arg1 = (Dali::Actor *)jarg1;
35942   {
35943     try {
35944       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
35945     } catch (std::out_of_range& e) {
35946       {
35947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35948       };
35949     } catch (std::exception& e) {
35950       {
35951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35952       };
35953     } catch (Dali::DaliException e) {
35954       {
35955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35956       };
35957     } catch (...) {
35958       {
35959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35960       };
35961     }
35962   }
35963
35964   jresult = result;
35965   return jresult;
35966 }
35967
35968
35969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
35970   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35971   Dali::ResizePolicy::Type arg2 ;
35972   Dali::Dimension::Type arg3 ;
35973
35974   arg1 = (Dali::Actor *)jarg1;
35975   arg2 = (Dali::ResizePolicy::Type)jarg2;
35976   arg3 = (Dali::Dimension::Type)jarg3;
35977   {
35978     try {
35979       (arg1)->SetResizePolicy(arg2,arg3);
35980     } catch (std::out_of_range& e) {
35981       {
35982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35983       };
35984     } catch (std::exception& e) {
35985       {
35986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35987       };
35988     } catch (Dali::DaliException e) {
35989       {
35990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35991       };
35992     } catch (...) {
35993       {
35994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35995       };
35996     }
35997   }
35998
35999 }
36000
36001
36002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36003   int jresult ;
36004   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36005   Dali::Dimension::Type arg2 ;
36006   Dali::ResizePolicy::Type result;
36007
36008   arg1 = (Dali::Actor *)jarg1;
36009   arg2 = (Dali::Dimension::Type)jarg2;
36010   {
36011     try {
36012       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36013     } catch (std::out_of_range& e) {
36014       {
36015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36016       };
36017     } catch (std::exception& e) {
36018       {
36019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36020       };
36021     } catch (Dali::DaliException e) {
36022       {
36023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36024       };
36025     } catch (...) {
36026       {
36027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36028       };
36029     }
36030   }
36031
36032   jresult = (int)result;
36033   return jresult;
36034 }
36035
36036
36037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36038   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36039   Dali::SizeScalePolicy::Type arg2 ;
36040
36041   arg1 = (Dali::Actor *)jarg1;
36042   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36043   {
36044     try {
36045       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36046     } catch (std::out_of_range& e) {
36047       {
36048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36049       };
36050     } catch (std::exception& e) {
36051       {
36052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36053       };
36054     } catch (Dali::DaliException e) {
36055       {
36056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36057       };
36058     } catch (...) {
36059       {
36060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36061       };
36062     }
36063   }
36064
36065 }
36066
36067
36068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36069   int jresult ;
36070   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36071   Dali::SizeScalePolicy::Type result;
36072
36073   arg1 = (Dali::Actor *)jarg1;
36074   {
36075     try {
36076       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36077     } catch (std::out_of_range& e) {
36078       {
36079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36080       };
36081     } catch (std::exception& e) {
36082       {
36083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36084       };
36085     } catch (Dali::DaliException e) {
36086       {
36087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36088       };
36089     } catch (...) {
36090       {
36091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36092       };
36093     }
36094   }
36095
36096   jresult = (int)result;
36097   return jresult;
36098 }
36099
36100
36101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36102   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36103   Dali::Vector3 *arg2 = 0 ;
36104
36105   arg1 = (Dali::Actor *)jarg1;
36106   arg2 = (Dali::Vector3 *)jarg2;
36107   if (!arg2) {
36108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36109     return ;
36110   }
36111   {
36112     try {
36113       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36114     } catch (std::out_of_range& e) {
36115       {
36116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36117       };
36118     } catch (std::exception& e) {
36119       {
36120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36121       };
36122     } catch (Dali::DaliException e) {
36123       {
36124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36125       };
36126     } catch (...) {
36127       {
36128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36129       };
36130     }
36131   }
36132
36133 }
36134
36135
36136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36137   void * jresult ;
36138   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36139   Dali::Vector3 result;
36140
36141   arg1 = (Dali::Actor *)jarg1;
36142   {
36143     try {
36144       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36145     } catch (std::out_of_range& e) {
36146       {
36147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36148       };
36149     } catch (std::exception& e) {
36150       {
36151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36152       };
36153     } catch (Dali::DaliException e) {
36154       {
36155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36156       };
36157     } catch (...) {
36158       {
36159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36160       };
36161     }
36162   }
36163
36164   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36165   return jresult;
36166 }
36167
36168
36169 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36170   float jresult ;
36171   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36172   float arg2 ;
36173   float result;
36174
36175   arg1 = (Dali::Actor *)jarg1;
36176   arg2 = (float)jarg2;
36177   {
36178     try {
36179       result = (float)(arg1)->GetHeightForWidth(arg2);
36180     } catch (std::out_of_range& e) {
36181       {
36182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36183       };
36184     } catch (std::exception& e) {
36185       {
36186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36187       };
36188     } catch (Dali::DaliException e) {
36189       {
36190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36191       };
36192     } catch (...) {
36193       {
36194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36195       };
36196     }
36197   }
36198
36199   jresult = result;
36200   return jresult;
36201 }
36202
36203
36204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36205   float jresult ;
36206   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36207   float arg2 ;
36208   float result;
36209
36210   arg1 = (Dali::Actor *)jarg1;
36211   arg2 = (float)jarg2;
36212   {
36213     try {
36214       result = (float)(arg1)->GetWidthForHeight(arg2);
36215     } catch (std::out_of_range& e) {
36216       {
36217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36218       };
36219     } catch (std::exception& e) {
36220       {
36221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36222       };
36223     } catch (Dali::DaliException e) {
36224       {
36225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36226       };
36227     } catch (...) {
36228       {
36229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36230       };
36231     }
36232   }
36233
36234   jresult = result;
36235   return jresult;
36236 }
36237
36238
36239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36240   float jresult ;
36241   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36242   Dali::Dimension::Type arg2 ;
36243   float result;
36244
36245   arg1 = (Dali::Actor *)jarg1;
36246   arg2 = (Dali::Dimension::Type)jarg2;
36247   {
36248     try {
36249       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36250     } catch (std::out_of_range& e) {
36251       {
36252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36253       };
36254     } catch (std::exception& e) {
36255       {
36256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36257       };
36258     } catch (Dali::DaliException e) {
36259       {
36260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36261       };
36262     } catch (...) {
36263       {
36264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36265       };
36266     }
36267   }
36268
36269   jresult = result;
36270   return jresult;
36271 }
36272
36273
36274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36275   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36276   Dali::Padding *arg2 = 0 ;
36277
36278   arg1 = (Dali::Actor *)jarg1;
36279   arg2 = (Dali::Padding *)jarg2;
36280   if (!arg2) {
36281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36282     return ;
36283   }
36284   {
36285     try {
36286       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36287     } catch (std::out_of_range& e) {
36288       {
36289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36290       };
36291     } catch (std::exception& e) {
36292       {
36293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36294       };
36295     } catch (Dali::DaliException e) {
36296       {
36297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36298       };
36299     } catch (...) {
36300       {
36301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36302       };
36303     }
36304   }
36305
36306 }
36307
36308
36309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36310   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36311   Dali::Padding *arg2 = 0 ;
36312
36313   arg1 = (Dali::Actor *)jarg1;
36314   arg2 = (Dali::Padding *)jarg2;
36315   if (!arg2) {
36316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36317     return ;
36318   }
36319   {
36320     try {
36321       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36322     } catch (std::out_of_range& e) {
36323       {
36324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36325       };
36326     } catch (std::exception& e) {
36327       {
36328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36329       };
36330     } catch (Dali::DaliException e) {
36331       {
36332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36333       };
36334     } catch (...) {
36335       {
36336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36337       };
36338     }
36339   }
36340
36341 }
36342
36343
36344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36345   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36346   Dali::Vector2 *arg2 = 0 ;
36347
36348   arg1 = (Dali::Actor *)jarg1;
36349   arg2 = (Dali::Vector2 *)jarg2;
36350   if (!arg2) {
36351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36352     return ;
36353   }
36354   {
36355     try {
36356       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36357     } catch (std::out_of_range& e) {
36358       {
36359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36360       };
36361     } catch (std::exception& e) {
36362       {
36363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36364       };
36365     } catch (Dali::DaliException e) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36368       };
36369     } catch (...) {
36370       {
36371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36372       };
36373     }
36374   }
36375
36376 }
36377
36378
36379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36380   void * jresult ;
36381   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36382   Dali::Vector2 result;
36383
36384   arg1 = (Dali::Actor *)jarg1;
36385   {
36386     try {
36387       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36388     } catch (std::out_of_range& e) {
36389       {
36390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36391       };
36392     } catch (std::exception& e) {
36393       {
36394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36395       };
36396     } catch (Dali::DaliException e) {
36397       {
36398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36399       };
36400     } catch (...) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36403       };
36404     }
36405   }
36406
36407   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36408   return jresult;
36409 }
36410
36411
36412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36413   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36414   Dali::Vector2 *arg2 = 0 ;
36415
36416   arg1 = (Dali::Actor *)jarg1;
36417   arg2 = (Dali::Vector2 *)jarg2;
36418   if (!arg2) {
36419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36420     return ;
36421   }
36422   {
36423     try {
36424       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36425     } catch (std::out_of_range& e) {
36426       {
36427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36428       };
36429     } catch (std::exception& e) {
36430       {
36431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36432       };
36433     } catch (Dali::DaliException e) {
36434       {
36435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36436       };
36437     } catch (...) {
36438       {
36439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36440       };
36441     }
36442   }
36443
36444 }
36445
36446
36447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36448   void * jresult ;
36449   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36450   Dali::Vector2 result;
36451
36452   arg1 = (Dali::Actor *)jarg1;
36453   {
36454     try {
36455       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36456     } catch (std::out_of_range& e) {
36457       {
36458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36459       };
36460     } catch (std::exception& e) {
36461       {
36462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36463       };
36464     } catch (Dali::DaliException e) {
36465       {
36466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36467       };
36468     } catch (...) {
36469       {
36470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36471       };
36472     }
36473   }
36474
36475   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36476   return jresult;
36477 }
36478
36479
36480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36481   int jresult ;
36482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36483   int result;
36484
36485   arg1 = (Dali::Actor *)jarg1;
36486   {
36487     try {
36488       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36489       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36490     } catch (std::out_of_range& e) {
36491       {
36492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36493       };
36494     } catch (std::exception& e) {
36495       {
36496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36497       };
36498     } catch (Dali::DaliException e) {
36499       {
36500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36501       };
36502     } catch (...) {
36503       {
36504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36505       };
36506     }
36507   }
36508
36509   jresult = result;
36510   return jresult;
36511 }
36512
36513
36514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36515   unsigned int jresult ;
36516   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36517   Dali::Renderer *arg2 = 0 ;
36518   unsigned int result;
36519
36520   arg1 = (Dali::Actor *)jarg1;
36521   arg2 = (Dali::Renderer *)jarg2;
36522   if (!arg2) {
36523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36524     return 0;
36525   }
36526   {
36527     try {
36528       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36529     } catch (std::out_of_range& e) {
36530       {
36531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36532       };
36533     } catch (std::exception& e) {
36534       {
36535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36536       };
36537     } catch (Dali::DaliException e) {
36538       {
36539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36540       };
36541     } catch (...) {
36542       {
36543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36544       };
36545     }
36546   }
36547
36548   jresult = result;
36549   return jresult;
36550 }
36551
36552
36553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36554   unsigned int jresult ;
36555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36556   unsigned int result;
36557
36558   arg1 = (Dali::Actor *)jarg1;
36559   {
36560     try {
36561       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36562     } catch (std::out_of_range& e) {
36563       {
36564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36565       };
36566     } catch (std::exception& e) {
36567       {
36568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36569       };
36570     } catch (Dali::DaliException e) {
36571       {
36572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36573       };
36574     } catch (...) {
36575       {
36576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36577       };
36578     }
36579   }
36580
36581   jresult = result;
36582   return jresult;
36583 }
36584
36585
36586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36587   void * jresult ;
36588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36589   unsigned int arg2 ;
36590   Dali::Renderer result;
36591
36592   arg1 = (Dali::Actor *)jarg1;
36593   arg2 = (unsigned int)jarg2;
36594   {
36595     try {
36596       result = (arg1)->GetRendererAt(arg2);
36597     } catch (std::out_of_range& e) {
36598       {
36599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36600       };
36601     } catch (std::exception& e) {
36602       {
36603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36604       };
36605     } catch (Dali::DaliException e) {
36606       {
36607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36608       };
36609     } catch (...) {
36610       {
36611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36612       };
36613     }
36614   }
36615
36616   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36617   return jresult;
36618 }
36619
36620
36621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36622   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36623   Dali::Renderer *arg2 = 0 ;
36624
36625   arg1 = (Dali::Actor *)jarg1;
36626   arg2 = (Dali::Renderer *)jarg2;
36627   if (!arg2) {
36628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36629     return ;
36630   }
36631   {
36632     try {
36633       (arg1)->RemoveRenderer(*arg2);
36634     } catch (std::out_of_range& e) {
36635       {
36636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36637       };
36638     } catch (std::exception& e) {
36639       {
36640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36641       };
36642     } catch (Dali::DaliException e) {
36643       {
36644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36645       };
36646     } catch (...) {
36647       {
36648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36649       };
36650     }
36651   }
36652
36653 }
36654
36655
36656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36657   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36658   unsigned int arg2 ;
36659
36660   arg1 = (Dali::Actor *)jarg1;
36661   arg2 = (unsigned int)jarg2;
36662   {
36663     try {
36664       (arg1)->RemoveRenderer(arg2);
36665     } catch (std::out_of_range& e) {
36666       {
36667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36668       };
36669     } catch (std::exception& e) {
36670       {
36671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36672       };
36673     } catch (Dali::DaliException e) {
36674       {
36675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36676       };
36677     } catch (...) {
36678       {
36679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36680       };
36681     }
36682   }
36683
36684 }
36685
36686
36687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36688   void * jresult ;
36689   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36690   Dali::Actor::TouchDataSignalType *result = 0 ;
36691
36692   arg1 = (Dali::Actor *)jarg1;
36693   {
36694     try {
36695       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36696     } catch (std::out_of_range& e) {
36697       {
36698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36699       };
36700     } catch (std::exception& e) {
36701       {
36702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36703       };
36704     } catch (Dali::DaliException e) {
36705       {
36706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36707       };
36708     } catch (...) {
36709       {
36710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36711       };
36712     }
36713   }
36714
36715   jresult = (void *)result;
36716   return jresult;
36717 }
36718
36719
36720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36721   void * jresult ;
36722   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36723   Dali::Actor::HoverSignalType *result = 0 ;
36724
36725   arg1 = (Dali::Actor *)jarg1;
36726   {
36727     try {
36728       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36729     } catch (std::out_of_range& e) {
36730       {
36731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36732       };
36733     } catch (std::exception& e) {
36734       {
36735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36736       };
36737     } catch (Dali::DaliException e) {
36738       {
36739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36740       };
36741     } catch (...) {
36742       {
36743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36744       };
36745     }
36746   }
36747
36748   jresult = (void *)result;
36749   return jresult;
36750 }
36751
36752
36753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36754   void * jresult ;
36755   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36756   Dali::Actor::WheelEventSignalType *result = 0 ;
36757
36758   arg1 = (Dali::Actor *)jarg1;
36759   {
36760     try {
36761       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36762     } catch (std::out_of_range& e) {
36763       {
36764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36765       };
36766     } catch (std::exception& e) {
36767       {
36768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36769       };
36770     } catch (Dali::DaliException e) {
36771       {
36772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36773       };
36774     } catch (...) {
36775       {
36776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36777       };
36778     }
36779   }
36780
36781   jresult = (void *)result;
36782   return jresult;
36783 }
36784
36785
36786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
36787   void * jresult ;
36788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36789   Dali::Actor::OnSceneSignalType *result = 0 ;
36790
36791   arg1 = (Dali::Actor *)jarg1;
36792   {
36793     try {
36794       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
36795     } catch (std::out_of_range& e) {
36796       {
36797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36798       };
36799     } catch (std::exception& e) {
36800       {
36801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36802       };
36803     } catch (Dali::DaliException e) {
36804       {
36805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36806       };
36807     } catch (...) {
36808       {
36809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36810       };
36811     }
36812   }
36813
36814   jresult = (void *)result;
36815   return jresult;
36816 }
36817
36818
36819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
36820   void * jresult ;
36821   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36822   Dali::Actor::OffSceneSignalType *result = 0 ;
36823
36824   arg1 = (Dali::Actor *)jarg1;
36825   {
36826     try {
36827       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
36828     } catch (std::out_of_range& e) {
36829       {
36830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36831       };
36832     } catch (std::exception& e) {
36833       {
36834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36835       };
36836     } catch (Dali::DaliException e) {
36837       {
36838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36839       };
36840     } catch (...) {
36841       {
36842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36843       };
36844     }
36845   }
36846
36847   jresult = (void *)result;
36848   return jresult;
36849 }
36850
36851
36852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
36853   void * jresult ;
36854   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36855   Dali::Actor::OnRelayoutSignalType *result = 0 ;
36856
36857   arg1 = (Dali::Actor *)jarg1;
36858   {
36859     try {
36860       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
36861     } catch (std::out_of_range& e) {
36862       {
36863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36864       };
36865     } catch (std::exception& e) {
36866       {
36867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36868       };
36869     } catch (Dali::DaliException e) {
36870       {
36871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36872       };
36873     } catch (...) {
36874       {
36875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36876       };
36877     }
36878   }
36879
36880   jresult = (void *)result;
36881   return jresult;
36882 }
36883
36884
36885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
36886   Dali::Actor *arg1 = 0 ;
36887
36888   arg1 = (Dali::Actor *)jarg1;
36889   if (!arg1) {
36890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36891     return ;
36892   }
36893   {
36894     try {
36895       Dali::UnparentAndReset(*arg1);
36896     } catch (std::out_of_range& e) {
36897       {
36898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36899       };
36900     } catch (std::exception& e) {
36901       {
36902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36903       };
36904     } catch (Dali::DaliException e) {
36905       {
36906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36907       };
36908     } catch (...) {
36909       {
36910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36911       };
36912     }
36913   }
36914
36915 }
36916
36917
36918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
36919   int jresult ;
36920   int result;
36921
36922   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
36923   jresult = (int)result;
36924   return jresult;
36925 }
36926
36927
36928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
36929   int jresult ;
36930   int result;
36931
36932   result = (int)Dali::Layer::Property::CLIPPING_BOX;
36933   jresult = (int)result;
36934   return jresult;
36935 }
36936
36937
36938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
36939   int jresult ;
36940   int result;
36941
36942   result = (int)Dali::Layer::Property::BEHAVIOR;
36943   jresult = (int)result;
36944   return jresult;
36945 }
36946
36947
36948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
36949   void * jresult ;
36950   Dali::Layer::Property *result = 0 ;
36951
36952   {
36953     try {
36954       result = (Dali::Layer::Property *)new Dali::Layer::Property();
36955     } catch (std::out_of_range& e) {
36956       {
36957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36958       };
36959     } catch (std::exception& e) {
36960       {
36961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36962       };
36963     } catch (Dali::DaliException e) {
36964       {
36965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36966       };
36967     } catch (...) {
36968       {
36969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36970       };
36971     }
36972   }
36973
36974   jresult = (void *)result;
36975   return jresult;
36976 }
36977
36978
36979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
36980   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
36981
36982   arg1 = (Dali::Layer::Property *)jarg1;
36983   {
36984     try {
36985       delete arg1;
36986     } catch (std::out_of_range& e) {
36987       {
36988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36989       };
36990     } catch (std::exception& e) {
36991       {
36992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36993       };
36994     } catch (Dali::DaliException e) {
36995       {
36996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36997       };
36998     } catch (...) {
36999       {
37000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37001       };
37002     }
37003   }
37004
37005 }
37006
37007
37008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37009   void * jresult ;
37010   Dali::Layer *result = 0 ;
37011
37012   {
37013     try {
37014       result = (Dali::Layer *)new Dali::Layer();
37015     } catch (std::out_of_range& e) {
37016       {
37017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37018       };
37019     } catch (std::exception& e) {
37020       {
37021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37022       };
37023     } catch (Dali::DaliException e) {
37024       {
37025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37026       };
37027     } catch (...) {
37028       {
37029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37030       };
37031     }
37032   }
37033
37034   jresult = (void *)result;
37035   return jresult;
37036 }
37037
37038
37039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37040   void * jresult ;
37041   Dali::Layer result;
37042
37043   {
37044     try {
37045       result = Dali::Layer::New();
37046     } catch (std::out_of_range& e) {
37047       {
37048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37049       };
37050     } catch (std::exception& e) {
37051       {
37052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37053       };
37054     } catch (Dali::DaliException e) {
37055       {
37056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37057       };
37058     } catch (...) {
37059       {
37060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37061       };
37062     }
37063   }
37064
37065   jresult = new Dali::Layer((const Dali::Layer &)result);
37066   return jresult;
37067 }
37068
37069
37070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37071   void * jresult ;
37072   Dali::BaseHandle arg1 ;
37073   Dali::BaseHandle *argp1 ;
37074   Dali::Layer result;
37075
37076   argp1 = (Dali::BaseHandle *)jarg1;
37077   if (!argp1) {
37078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37079     return 0;
37080   }
37081   arg1 = *argp1;
37082   {
37083     try {
37084       result = Dali::Layer::DownCast(arg1);
37085     } catch (std::out_of_range& e) {
37086       {
37087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37088       };
37089     } catch (std::exception& e) {
37090       {
37091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37092       };
37093     } catch (Dali::DaliException e) {
37094       {
37095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37096       };
37097     } catch (...) {
37098       {
37099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37100       };
37101     }
37102   }
37103
37104   jresult = new Dali::Layer((const Dali::Layer &)result);
37105   return jresult;
37106 }
37107
37108
37109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37110   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37111
37112   arg1 = (Dali::Layer *)jarg1;
37113   {
37114     try {
37115       delete arg1;
37116     } catch (std::out_of_range& e) {
37117       {
37118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37119       };
37120     } catch (std::exception& e) {
37121       {
37122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37123       };
37124     } catch (Dali::DaliException e) {
37125       {
37126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37127       };
37128     } catch (...) {
37129       {
37130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37131       };
37132     }
37133   }
37134
37135 }
37136
37137
37138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37139   void * jresult ;
37140   Dali::Layer *arg1 = 0 ;
37141   Dali::Layer *result = 0 ;
37142
37143   arg1 = (Dali::Layer *)jarg1;
37144   if (!arg1) {
37145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37146     return 0;
37147   }
37148   {
37149     try {
37150       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37151     } catch (std::out_of_range& e) {
37152       {
37153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37154       };
37155     } catch (std::exception& e) {
37156       {
37157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37158       };
37159     } catch (Dali::DaliException e) {
37160       {
37161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37162       };
37163     } catch (...) {
37164       {
37165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37166       };
37167     }
37168   }
37169
37170   jresult = (void *)result;
37171   return jresult;
37172 }
37173
37174
37175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37176   void * jresult ;
37177   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37178   Dali::Layer *arg2 = 0 ;
37179   Dali::Layer *result = 0 ;
37180
37181   arg1 = (Dali::Layer *)jarg1;
37182   arg2 = (Dali::Layer *)jarg2;
37183   if (!arg2) {
37184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37185     return 0;
37186   }
37187   {
37188     try {
37189       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37190     } catch (std::out_of_range& e) {
37191       {
37192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37193       };
37194     } catch (std::exception& e) {
37195       {
37196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37197       };
37198     } catch (Dali::DaliException e) {
37199       {
37200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37201       };
37202     } catch (...) {
37203       {
37204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37205       };
37206     }
37207   }
37208
37209   jresult = (void *)result;
37210   return jresult;
37211 }
37212
37213
37214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37215   unsigned int jresult ;
37216   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37217   unsigned int result;
37218
37219   arg1 = (Dali::Layer *)jarg1;
37220   {
37221     try {
37222       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37223     } catch (std::out_of_range& e) {
37224       {
37225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37226       };
37227     } catch (std::exception& e) {
37228       {
37229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37230       };
37231     } catch (Dali::DaliException e) {
37232       {
37233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37234       };
37235     } catch (...) {
37236       {
37237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37238       };
37239     }
37240   }
37241
37242   jresult = result;
37243   return jresult;
37244 }
37245
37246
37247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37248   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37249
37250   arg1 = (Dali::Layer *)jarg1;
37251   {
37252     try {
37253       (arg1)->Raise();
37254     } catch (std::out_of_range& e) {
37255       {
37256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37257       };
37258     } catch (std::exception& e) {
37259       {
37260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37261       };
37262     } catch (Dali::DaliException e) {
37263       {
37264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37265       };
37266     } catch (...) {
37267       {
37268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37269       };
37270     }
37271   }
37272
37273 }
37274
37275
37276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37277   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37278
37279   arg1 = (Dali::Layer *)jarg1;
37280   {
37281     try {
37282       (arg1)->Lower();
37283     } catch (std::out_of_range& e) {
37284       {
37285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37286       };
37287     } catch (std::exception& e) {
37288       {
37289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37290       };
37291     } catch (Dali::DaliException e) {
37292       {
37293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37294       };
37295     } catch (...) {
37296       {
37297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37298       };
37299     }
37300   }
37301
37302 }
37303
37304
37305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37306   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37307   Dali::Layer arg2 ;
37308   Dali::Layer *argp2 ;
37309
37310   arg1 = (Dali::Layer *)jarg1;
37311   argp2 = (Dali::Layer *)jarg2;
37312   if (!argp2) {
37313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37314     return ;
37315   }
37316   arg2 = *argp2;
37317   {
37318     try {
37319       (arg1)->RaiseAbove(arg2);
37320     } catch (std::out_of_range& e) {
37321       {
37322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37323       };
37324     } catch (std::exception& e) {
37325       {
37326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37327       };
37328     } catch (Dali::DaliException e) {
37329       {
37330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37331       };
37332     } catch (...) {
37333       {
37334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37335       };
37336     }
37337   }
37338
37339 }
37340
37341
37342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37343   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37344   Dali::Layer arg2 ;
37345   Dali::Layer *argp2 ;
37346
37347   arg1 = (Dali::Layer *)jarg1;
37348   argp2 = (Dali::Layer *)jarg2;
37349   if (!argp2) {
37350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37351     return ;
37352   }
37353   arg2 = *argp2;
37354   {
37355     try {
37356       (arg1)->LowerBelow(arg2);
37357     } catch (std::out_of_range& e) {
37358       {
37359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37360       };
37361     } catch (std::exception& e) {
37362       {
37363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37364       };
37365     } catch (Dali::DaliException e) {
37366       {
37367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37368       };
37369     } catch (...) {
37370       {
37371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37372       };
37373     }
37374   }
37375
37376 }
37377
37378
37379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37380   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37381
37382   arg1 = (Dali::Layer *)jarg1;
37383   {
37384     try {
37385       (arg1)->RaiseToTop();
37386     } catch (std::out_of_range& e) {
37387       {
37388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37389       };
37390     } catch (std::exception& e) {
37391       {
37392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37393       };
37394     } catch (Dali::DaliException e) {
37395       {
37396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37397       };
37398     } catch (...) {
37399       {
37400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37401       };
37402     }
37403   }
37404
37405 }
37406
37407
37408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37409   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37410
37411   arg1 = (Dali::Layer *)jarg1;
37412   {
37413     try {
37414       (arg1)->LowerToBottom();
37415     } catch (std::out_of_range& e) {
37416       {
37417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37418       };
37419     } catch (std::exception& e) {
37420       {
37421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37422       };
37423     } catch (Dali::DaliException e) {
37424       {
37425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37426       };
37427     } catch (...) {
37428       {
37429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37430       };
37431     }
37432   }
37433
37434 }
37435
37436
37437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37438   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37439   Dali::Layer arg2 ;
37440   Dali::Layer *argp2 ;
37441
37442   arg1 = (Dali::Layer *)jarg1;
37443   argp2 = (Dali::Layer *)jarg2;
37444   if (!argp2) {
37445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37446     return ;
37447   }
37448   arg2 = *argp2;
37449   {
37450     try {
37451       (arg1)->MoveAbove(arg2);
37452     } catch (std::out_of_range& e) {
37453       {
37454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37455       };
37456     } catch (std::exception& e) {
37457       {
37458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37459       };
37460     } catch (Dali::DaliException e) {
37461       {
37462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37463       };
37464     } catch (...) {
37465       {
37466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37467       };
37468     }
37469   }
37470
37471 }
37472
37473
37474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37475   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37476   Dali::Layer arg2 ;
37477   Dali::Layer *argp2 ;
37478
37479   arg1 = (Dali::Layer *)jarg1;
37480   argp2 = (Dali::Layer *)jarg2;
37481   if (!argp2) {
37482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37483     return ;
37484   }
37485   arg2 = *argp2;
37486   {
37487     try {
37488       (arg1)->MoveBelow(arg2);
37489     } catch (std::out_of_range& e) {
37490       {
37491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37492       };
37493     } catch (std::exception& e) {
37494       {
37495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37496       };
37497     } catch (Dali::DaliException e) {
37498       {
37499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37500       };
37501     } catch (...) {
37502       {
37503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37504       };
37505     }
37506   }
37507
37508 }
37509
37510
37511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37512   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37513   Dali::Layer::Behavior arg2 ;
37514
37515   arg1 = (Dali::Layer *)jarg1;
37516   arg2 = (Dali::Layer::Behavior)jarg2;
37517   {
37518     try {
37519       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37520     } catch (std::out_of_range& e) {
37521       {
37522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37523       };
37524     } catch (std::exception& e) {
37525       {
37526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37527       };
37528     } catch (Dali::DaliException e) {
37529       {
37530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37531       };
37532     } catch (...) {
37533       {
37534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37535       };
37536     }
37537   }
37538
37539 }
37540
37541
37542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37543   int jresult ;
37544   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37545   Dali::Layer::Behavior result;
37546
37547   arg1 = (Dali::Layer *)jarg1;
37548   {
37549     try {
37550       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37551     } catch (std::out_of_range& e) {
37552       {
37553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37554       };
37555     } catch (std::exception& e) {
37556       {
37557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37558       };
37559     } catch (Dali::DaliException e) {
37560       {
37561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37562       };
37563     } catch (...) {
37564       {
37565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37566       };
37567     }
37568   }
37569
37570   jresult = (int)result;
37571   return jresult;
37572 }
37573
37574
37575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37576   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37577   bool arg2 ;
37578
37579   arg1 = (Dali::Layer *)jarg1;
37580   arg2 = jarg2 ? true : false;
37581   {
37582     try {
37583       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37584     } catch (std::out_of_range& e) {
37585       {
37586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37587       };
37588     } catch (std::exception& e) {
37589       {
37590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37591       };
37592     } catch (Dali::DaliException e) {
37593       {
37594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37595       };
37596     } catch (...) {
37597       {
37598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37599       };
37600     }
37601   }
37602
37603 }
37604
37605
37606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37607   unsigned int jresult ;
37608   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37609   bool result;
37610
37611   arg1 = (Dali::Layer *)jarg1;
37612   {
37613     try {
37614       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37615     } catch (std::out_of_range& e) {
37616       {
37617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37618       };
37619     } catch (std::exception& e) {
37620       {
37621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37622       };
37623     } catch (Dali::DaliException e) {
37624       {
37625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37626       };
37627     } catch (...) {
37628       {
37629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37630       };
37631     }
37632   }
37633
37634   jresult = result;
37635   return jresult;
37636 }
37637
37638
37639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37640   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37641   int arg2 ;
37642   int arg3 ;
37643   int arg4 ;
37644   int arg5 ;
37645
37646   arg1 = (Dali::Layer *)jarg1;
37647   arg2 = (int)jarg2;
37648   arg3 = (int)jarg3;
37649   arg4 = (int)jarg4;
37650   arg5 = (int)jarg5;
37651   {
37652     try {
37653       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37654     } catch (std::out_of_range& e) {
37655       {
37656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37657       };
37658     } catch (std::exception& e) {
37659       {
37660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37661       };
37662     } catch (Dali::DaliException e) {
37663       {
37664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37665       };
37666     } catch (...) {
37667       {
37668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37669       };
37670     }
37671   }
37672
37673 }
37674
37675
37676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37677   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37678   Dali::ClippingBox arg2 ;
37679   Dali::ClippingBox *argp2 ;
37680
37681   arg1 = (Dali::Layer *)jarg1;
37682   argp2 = (Dali::ClippingBox *)jarg2;
37683   if (!argp2) {
37684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37685     return ;
37686   }
37687   arg2 = *argp2;
37688   {
37689     try {
37690       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
37691     } catch (std::out_of_range& e) {
37692       {
37693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37694       };
37695     } catch (std::exception& e) {
37696       {
37697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37698       };
37699     } catch (Dali::DaliException e) {
37700       {
37701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37702       };
37703     } catch (...) {
37704       {
37705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37706       };
37707     }
37708   }
37709
37710 }
37711
37712
37713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37714   void * jresult ;
37715   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37716   Dali::ClippingBox result;
37717
37718   arg1 = (Dali::Layer *)jarg1;
37719   {
37720     try {
37721       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
37722     } catch (std::out_of_range& e) {
37723       {
37724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37725       };
37726     } catch (std::exception& e) {
37727       {
37728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37729       };
37730     } catch (Dali::DaliException e) {
37731       {
37732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37733       };
37734     } catch (...) {
37735       {
37736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37737       };
37738     }
37739   }
37740
37741   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37742   return jresult;
37743 }
37744
37745
37746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37747   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37748   bool arg2 ;
37749
37750   arg1 = (Dali::Layer *)jarg1;
37751   arg2 = jarg2 ? true : false;
37752   {
37753     try {
37754       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
37755     } catch (std::out_of_range& e) {
37756       {
37757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37758       };
37759     } catch (std::exception& e) {
37760       {
37761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37762       };
37763     } catch (Dali::DaliException e) {
37764       {
37765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37766       };
37767     } catch (...) {
37768       {
37769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37770       };
37771     }
37772   }
37773
37774 }
37775
37776
37777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37778   unsigned int jresult ;
37779   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37780   bool result;
37781
37782   arg1 = (Dali::Layer *)jarg1;
37783   {
37784     try {
37785       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
37786     } catch (std::out_of_range& e) {
37787       {
37788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37789       };
37790     } catch (std::exception& e) {
37791       {
37792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37793       };
37794     } catch (Dali::DaliException e) {
37795       {
37796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37797       };
37798     } catch (...) {
37799       {
37800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37801       };
37802     }
37803   }
37804
37805   jresult = result;
37806   return jresult;
37807 }
37808
37809
37810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37811   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37812   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37813
37814   arg1 = (Dali::Layer *)jarg1;
37815   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37816   {
37817     try {
37818       (arg1)->SetSortFunction(arg2);
37819     } catch (std::out_of_range& e) {
37820       {
37821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37822       };
37823     } catch (std::exception& e) {
37824       {
37825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37826       };
37827     } catch (Dali::DaliException e) {
37828       {
37829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37830       };
37831     } catch (...) {
37832       {
37833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37834       };
37835     }
37836   }
37837
37838 }
37839
37840
37841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37842   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37843   bool arg2 ;
37844
37845   arg1 = (Dali::Layer *)jarg1;
37846   arg2 = jarg2 ? true : false;
37847   {
37848     try {
37849       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
37850     } catch (std::out_of_range& e) {
37851       {
37852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37853       };
37854     } catch (std::exception& e) {
37855       {
37856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37857       };
37858     } catch (Dali::DaliException e) {
37859       {
37860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37861       };
37862     } catch (...) {
37863       {
37864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37865       };
37866     }
37867   }
37868
37869 }
37870
37871
37872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
37873   unsigned int jresult ;
37874   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37875   bool result;
37876
37877   arg1 = (Dali::Layer *)jarg1;
37878   {
37879     try {
37880       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
37881     } catch (std::out_of_range& e) {
37882       {
37883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37884       };
37885     } catch (std::exception& e) {
37886       {
37887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37888       };
37889     } catch (Dali::DaliException e) {
37890       {
37891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37892       };
37893     } catch (...) {
37894       {
37895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37896       };
37897     }
37898   }
37899
37900   jresult = result;
37901   return jresult;
37902 }
37903
37904
37905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
37906   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37907   bool arg2 ;
37908
37909   arg1 = (Dali::Layer *)jarg1;
37910   arg2 = jarg2 ? true : false;
37911   {
37912     try {
37913       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
37914     } catch (std::out_of_range& e) {
37915       {
37916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37917       };
37918     } catch (std::exception& e) {
37919       {
37920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37921       };
37922     } catch (Dali::DaliException e) {
37923       {
37924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37925       };
37926     } catch (...) {
37927       {
37928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37929       };
37930     }
37931   }
37932
37933 }
37934
37935
37936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
37937   unsigned int jresult ;
37938   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37939   bool result;
37940
37941   arg1 = (Dali::Layer *)jarg1;
37942   {
37943     try {
37944       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
37945     } catch (std::out_of_range& e) {
37946       {
37947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37948       };
37949     } catch (std::exception& e) {
37950       {
37951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37952       };
37953     } catch (Dali::DaliException e) {
37954       {
37955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37956       };
37957     } catch (...) {
37958       {
37959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37960       };
37961     }
37962   }
37963
37964   jresult = result;
37965   return jresult;
37966 }
37967
37968
37969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
37970   void * jresult ;
37971   Dali::Stage result;
37972
37973   {
37974     try {
37975       result = Dali::Stage::GetCurrent();
37976     } catch (std::out_of_range& e) {
37977       {
37978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37979       };
37980     } catch (std::exception& e) {
37981       {
37982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37983       };
37984     } catch (Dali::DaliException e) {
37985       {
37986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37987       };
37988     } catch (...) {
37989       {
37990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37991       };
37992     }
37993   }
37994
37995   jresult = new Dali::Stage((const Dali::Stage &)result);
37996   return jresult;
37997 }
37998
37999
38000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38001   unsigned int jresult ;
38002   bool result;
38003
38004   {
38005     try {
38006       result = (bool)Dali::Stage::IsInstalled();
38007     } catch (std::out_of_range& e) {
38008       {
38009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38010       };
38011     } catch (std::exception& e) {
38012       {
38013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38014       };
38015     } catch (Dali::DaliException e) {
38016       {
38017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38018       };
38019     } catch (...) {
38020       {
38021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38022       };
38023     }
38024   }
38025
38026   jresult = result;
38027   return jresult;
38028 }
38029
38030
38031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38032   void * jresult ;
38033   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38034   Dali::Vector2 result;
38035
38036   arg1 = (Dali::Stage *)jarg1;
38037   {
38038     try {
38039       result = ((Dali::Stage const *)arg1)->GetDpi();
38040     } catch (std::out_of_range& e) {
38041       {
38042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38043       };
38044     } catch (std::exception& e) {
38045       {
38046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38047       };
38048     } catch (Dali::DaliException e) {
38049       {
38050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38051       };
38052     } catch (...) {
38053       {
38054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38055       };
38056     }
38057   }
38058
38059   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38060   return jresult;
38061 }
38062
38063
38064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38065   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38066   float arg2 ;
38067
38068   arg1 = (Dali::Stage *)jarg1;
38069   arg2 = (float)jarg2;
38070   {
38071     try {
38072       (arg1)->KeepRendering(arg2);
38073     } catch (std::out_of_range& e) {
38074       {
38075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38076       };
38077     } catch (std::exception& e) {
38078       {
38079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38080       };
38081     } catch (Dali::DaliException e) {
38082       {
38083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38084       };
38085     } catch (...) {
38086       {
38087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38088       };
38089     }
38090   }
38091
38092 }
38093
38094
38095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38096   void * jresult ;
38097   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38098   Dali::Stage::KeyEventSignalType *result = 0 ;
38099
38100   arg1 = (Dali::Stage *)jarg1;
38101   {
38102     try {
38103       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38104     } catch (std::out_of_range& e) {
38105       {
38106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38107       };
38108     } catch (std::exception& e) {
38109       {
38110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38111       };
38112     } catch (Dali::DaliException e) {
38113       {
38114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38115       };
38116     } catch (...) {
38117       {
38118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38119       };
38120     }
38121   }
38122
38123   jresult = (void *)result;
38124   return jresult;
38125 }
38126
38127
38128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38129   void * jresult ;
38130   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38131   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38132
38133   arg1 = (Dali::Stage *)jarg1;
38134   {
38135     try {
38136       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38137     } catch (std::out_of_range& e) {
38138       {
38139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38140       };
38141     } catch (std::exception& e) {
38142       {
38143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38144       };
38145     } catch (Dali::DaliException e) {
38146       {
38147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38148       };
38149     } catch (...) {
38150       {
38151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38152       };
38153     }
38154   }
38155
38156   jresult = (void *)result;
38157   return jresult;
38158 }
38159
38160
38161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38162   void * jresult ;
38163   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38164   Dali::Stage::TouchSignalType *result = 0 ;
38165
38166   arg1 = (Dali::Stage *)jarg1;
38167   {
38168     try {
38169       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38170     } catch (std::out_of_range& e) {
38171       {
38172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38173       };
38174     } catch (std::exception& e) {
38175       {
38176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38177       };
38178     } catch (Dali::DaliException e) {
38179       {
38180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38181       };
38182     } catch (...) {
38183       {
38184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38185       };
38186     }
38187   }
38188
38189   jresult = (void *)result;
38190   return jresult;
38191 }
38192
38193
38194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38195   void * jresult ;
38196   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38197   Dali::Stage::WheelEventSignalType *result = 0 ;
38198
38199   arg1 = (Dali::Stage *)jarg1;
38200   {
38201     try {
38202       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38203     } catch (std::out_of_range& e) {
38204       {
38205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38206       };
38207     } catch (std::exception& e) {
38208       {
38209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38210       };
38211     } catch (Dali::DaliException e) {
38212       {
38213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38214       };
38215     } catch (...) {
38216       {
38217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38218       };
38219     }
38220   }
38221
38222   jresult = (void *)result;
38223   return jresult;
38224 }
38225
38226
38227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38228   void * jresult ;
38229   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38230   Dali::Stage::ContextStatusSignal *result = 0 ;
38231
38232   arg1 = (Dali::Stage *)jarg1;
38233   {
38234     try {
38235       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38236     } catch (std::out_of_range& e) {
38237       {
38238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38239       };
38240     } catch (std::exception& e) {
38241       {
38242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38243       };
38244     } catch (Dali::DaliException e) {
38245       {
38246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38247       };
38248     } catch (...) {
38249       {
38250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38251       };
38252     }
38253   }
38254
38255   jresult = (void *)result;
38256   return jresult;
38257 }
38258
38259
38260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38261   void * jresult ;
38262   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38263   Dali::Stage::ContextStatusSignal *result = 0 ;
38264
38265   arg1 = (Dali::Stage *)jarg1;
38266   {
38267     try {
38268       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38269     } catch (std::out_of_range& e) {
38270       {
38271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38272       };
38273     } catch (std::exception& e) {
38274       {
38275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38276       };
38277     } catch (Dali::DaliException e) {
38278       {
38279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38280       };
38281     } catch (...) {
38282       {
38283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38284       };
38285     }
38286   }
38287
38288   jresult = (void *)result;
38289   return jresult;
38290 }
38291
38292
38293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38294   void * jresult ;
38295   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38296   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38297
38298   arg1 = (Dali::Stage *)jarg1;
38299   {
38300     try {
38301       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38302     } catch (std::out_of_range& e) {
38303       {
38304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38305       };
38306     } catch (std::exception& e) {
38307       {
38308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38309       };
38310     } catch (Dali::DaliException e) {
38311       {
38312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38313       };
38314     } catch (...) {
38315       {
38316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38317       };
38318     }
38319   }
38320
38321   jresult = (void *)result;
38322   return jresult;
38323 }
38324
38325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38326   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38327   Dali::DevelStage::Rendering arg2 ;
38328
38329   arg1 = (Dali::Stage *)jarg1;
38330   arg2 = (Dali::DevelStage::Rendering)jarg2;
38331   {
38332     try {
38333       DevelStage::SetRenderingBehavior(*arg1,arg2);
38334     } catch (std::out_of_range& e) {
38335       {
38336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38337       };
38338     } catch (std::exception& e) {
38339       {
38340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38341       };
38342     } catch (Dali::DaliException e) {
38343       {
38344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38345       };
38346     } catch (...) {
38347       {
38348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38349       };
38350     }
38351   }
38352
38353 }
38354
38355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38356
38357   int jresult ;
38358   int result ;
38359   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38360
38361   arg1 = (Dali::Stage *)jarg1;
38362   {
38363     try {
38364       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38365     } catch (std::out_of_range& e) {
38366       {
38367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38368       };
38369     } catch (std::exception& e) {
38370       {
38371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38372       };
38373     } catch (Dali::DaliException e) {
38374       {
38375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38376       };
38377     } catch (...) {
38378       {
38379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38380       };
38381     }
38382   }
38383
38384   jresult = result;
38385   return jresult;
38386 }
38387
38388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38389   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38390
38391   arg1 = (Dali::RelayoutContainer *)jarg1;
38392   {
38393     try {
38394       delete arg1;
38395     } catch (std::out_of_range& e) {
38396       {
38397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38398       };
38399     } catch (std::exception& e) {
38400       {
38401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38402       };
38403     } catch (Dali::DaliException e) {
38404       {
38405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38406       };
38407     } catch (...) {
38408       {
38409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38410       };
38411     }
38412   }
38413
38414 }
38415
38416
38417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38418   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38419   Dali::Actor *arg2 = 0 ;
38420   Dali::Vector2 *arg3 = 0 ;
38421
38422   arg1 = (Dali::RelayoutContainer *)jarg1;
38423   arg2 = (Dali::Actor *)jarg2;
38424   if (!arg2) {
38425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38426     return ;
38427   }
38428   arg3 = (Dali::Vector2 *)jarg3;
38429   if (!arg3) {
38430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38431     return ;
38432   }
38433   {
38434     try {
38435       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38436     } catch (std::out_of_range& e) {
38437       {
38438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38439       };
38440     } catch (std::exception& e) {
38441       {
38442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38443       };
38444     } catch (Dali::DaliException e) {
38445       {
38446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38447       };
38448     } catch (...) {
38449       {
38450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38451       };
38452     }
38453   }
38454
38455 }
38456
38457
38458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38459   void * jresult ;
38460   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38461   Dali::CustomActor result;
38462
38463   arg1 = (Dali::CustomActorImpl *)jarg1;
38464   {
38465     try {
38466       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38467     } catch (std::out_of_range& e) {
38468       {
38469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38470       };
38471     } catch (std::exception& e) {
38472       {
38473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38474       };
38475     } catch (Dali::DaliException e) {
38476       {
38477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38478       };
38479     } catch (...) {
38480       {
38481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38482       };
38483     }
38484   }
38485
38486   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38487   return jresult;
38488 }
38489
38490
38491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
38492   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38493   int arg2 ;
38494
38495   arg1 = (Dali::CustomActorImpl *)jarg1;
38496   arg2 = (int)jarg2;
38497   {
38498     try {
38499       (arg1)->OnSceneConnection(arg2);
38500     } catch (std::out_of_range& e) {
38501       {
38502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38503       };
38504     } catch (std::exception& e) {
38505       {
38506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38507       };
38508     } catch (Dali::DaliException e) {
38509       {
38510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38511       };
38512     } catch (...) {
38513       {
38514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38515       };
38516     }
38517   }
38518
38519 }
38520
38521
38522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
38523   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38524
38525   arg1 = (Dali::CustomActorImpl *)jarg1;
38526   {
38527     try {
38528       (arg1)->OnSceneDisconnection();
38529     } catch (std::out_of_range& e) {
38530       {
38531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38532       };
38533     } catch (std::exception& e) {
38534       {
38535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38536       };
38537     } catch (Dali::DaliException e) {
38538       {
38539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38540       };
38541     } catch (...) {
38542       {
38543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38544       };
38545     }
38546   }
38547
38548 }
38549
38550
38551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
38552   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38553   Dali::Actor *arg2 = 0 ;
38554
38555   arg1 = (Dali::CustomActorImpl *)jarg1;
38556   arg2 = (Dali::Actor *)jarg2;
38557   if (!arg2) {
38558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38559     return ;
38560   }
38561   {
38562     try {
38563       (arg1)->OnChildAdd(*arg2);
38564     } catch (std::out_of_range& e) {
38565       {
38566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38567       };
38568     } catch (std::exception& e) {
38569       {
38570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38571       };
38572     } catch (Dali::DaliException e) {
38573       {
38574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38575       };
38576     } catch (...) {
38577       {
38578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38579       };
38580     }
38581   }
38582
38583 }
38584
38585
38586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
38587   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38588   Dali::Actor *arg2 = 0 ;
38589
38590   arg1 = (Dali::CustomActorImpl *)jarg1;
38591   arg2 = (Dali::Actor *)jarg2;
38592   if (!arg2) {
38593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38594     return ;
38595   }
38596   {
38597     try {
38598       (arg1)->OnChildRemove(*arg2);
38599     } catch (std::out_of_range& e) {
38600       {
38601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38602       };
38603     } catch (std::exception& e) {
38604       {
38605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38606       };
38607     } catch (Dali::DaliException e) {
38608       {
38609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38610       };
38611     } catch (...) {
38612       {
38613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38614       };
38615     }
38616   }
38617
38618 }
38619
38620
38621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38622   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38623   Dali::Property::Index arg2 ;
38624   Dali::Property::Value arg3 ;
38625   Dali::Property::Value *argp3 ;
38626
38627   arg1 = (Dali::CustomActorImpl *)jarg1;
38628   arg2 = (Dali::Property::Index)jarg2;
38629   argp3 = (Dali::Property::Value *)jarg3;
38630   if (!argp3) {
38631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38632     return ;
38633   }
38634   arg3 = *argp3;
38635   {
38636     try {
38637       (arg1)->OnPropertySet(arg2,arg3);
38638     } catch (std::out_of_range& e) {
38639       {
38640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38641       };
38642     } catch (std::exception& e) {
38643       {
38644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38645       };
38646     } catch (Dali::DaliException e) {
38647       {
38648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38649       };
38650     } catch (...) {
38651       {
38652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38653       };
38654     }
38655   }
38656
38657 }
38658
38659
38660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
38661   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38662   Dali::Vector3 *arg2 = 0 ;
38663
38664   arg1 = (Dali::CustomActorImpl *)jarg1;
38665   arg2 = (Dali::Vector3 *)jarg2;
38666   if (!arg2) {
38667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38668     return ;
38669   }
38670   {
38671     try {
38672       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
38673     } catch (std::out_of_range& e) {
38674       {
38675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38676       };
38677     } catch (std::exception& e) {
38678       {
38679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38680       };
38681     } catch (Dali::DaliException e) {
38682       {
38683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38684       };
38685     } catch (...) {
38686       {
38687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38688       };
38689     }
38690   }
38691
38692 }
38693
38694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
38695   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38696   Dali::Animation *arg2 = 0 ;
38697   Dali::Vector3 *arg3 = 0 ;
38698
38699   arg1 = (Dali::CustomActorImpl *)jarg1;
38700   arg2 = (Dali::Animation *)jarg2;
38701   if (!arg2) {
38702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38703     return ;
38704   }
38705   arg3 = (Dali::Vector3 *)jarg3;
38706   if (!arg3) {
38707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38708     return ;
38709   }
38710   {
38711     try {
38712       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
38713     } catch (std::out_of_range& e) {
38714       {
38715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38716       };
38717     } catch (std::exception& e) {
38718       {
38719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38720       };
38721     } catch (Dali::DaliException e) {
38722       {
38723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38724       };
38725     } catch (...) {
38726       {
38727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38728       };
38729     }
38730   }
38731
38732 }
38733
38734
38735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
38736   unsigned int jresult ;
38737   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38738   Dali::TouchEvent *arg2 = 0 ;
38739   bool result;
38740
38741   arg1 = (Dali::CustomActorImpl *)jarg1;
38742   arg2 = (Dali::TouchEvent *)jarg2;
38743   if (!arg2) {
38744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
38745     return 0;
38746   }
38747   {
38748     try {
38749       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
38750     } catch (std::out_of_range& e) {
38751       {
38752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38753       };
38754     } catch (std::exception& e) {
38755       {
38756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38757       };
38758     } catch (Dali::DaliException e) {
38759       {
38760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38761       };
38762     } catch (...) {
38763       {
38764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38765       };
38766     }
38767   }
38768
38769   jresult = result;
38770   return jresult;
38771 }
38772
38773
38774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
38775   unsigned int jresult ;
38776   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38777   Dali::HoverEvent *arg2 = 0 ;
38778   bool result;
38779
38780   arg1 = (Dali::CustomActorImpl *)jarg1;
38781   arg2 = (Dali::HoverEvent *)jarg2;
38782   if (!arg2) {
38783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
38784     return 0;
38785   }
38786   {
38787     try {
38788       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
38789     } catch (std::out_of_range& e) {
38790       {
38791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38792       };
38793     } catch (std::exception& e) {
38794       {
38795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38796       };
38797     } catch (Dali::DaliException e) {
38798       {
38799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38800       };
38801     } catch (...) {
38802       {
38803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38804       };
38805     }
38806   }
38807
38808   jresult = result;
38809   return jresult;
38810 }
38811
38812
38813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
38814   unsigned int jresult ;
38815   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38816   Dali::KeyEvent *arg2 = 0 ;
38817   bool result;
38818
38819   arg1 = (Dali::CustomActorImpl *)jarg1;
38820   arg2 = (Dali::KeyEvent *)jarg2;
38821   if (!arg2) {
38822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38823     return 0;
38824   }
38825   {
38826     try {
38827       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
38828     } catch (std::out_of_range& e) {
38829       {
38830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38831       };
38832     } catch (std::exception& e) {
38833       {
38834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38835       };
38836     } catch (Dali::DaliException e) {
38837       {
38838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38839       };
38840     } catch (...) {
38841       {
38842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38843       };
38844     }
38845   }
38846
38847   jresult = result;
38848   return jresult;
38849 }
38850
38851
38852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
38853   unsigned int jresult ;
38854   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38855   Dali::WheelEvent *arg2 = 0 ;
38856   bool result;
38857
38858   arg1 = (Dali::CustomActorImpl *)jarg1;
38859   arg2 = (Dali::WheelEvent *)jarg2;
38860   if (!arg2) {
38861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
38862     return 0;
38863   }
38864   {
38865     try {
38866       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
38867     } catch (std::out_of_range& e) {
38868       {
38869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38870       };
38871     } catch (std::exception& e) {
38872       {
38873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38874       };
38875     } catch (Dali::DaliException e) {
38876       {
38877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38878       };
38879     } catch (...) {
38880       {
38881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38882       };
38883     }
38884   }
38885
38886   jresult = result;
38887   return jresult;
38888 }
38889
38890
38891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
38892   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38893   Dali::Vector2 *arg2 = 0 ;
38894   Dali::RelayoutContainer *arg3 = 0 ;
38895
38896   arg1 = (Dali::CustomActorImpl *)jarg1;
38897   arg2 = (Dali::Vector2 *)jarg2;
38898   if (!arg2) {
38899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38900     return ;
38901   }
38902   arg3 = (Dali::RelayoutContainer *)jarg3;
38903   if (!arg3) {
38904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
38905     return ;
38906   }
38907   {
38908     try {
38909       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
38910     } catch (std::out_of_range& e) {
38911       {
38912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38913       };
38914     } catch (std::exception& e) {
38915       {
38916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38917       };
38918     } catch (Dali::DaliException e) {
38919       {
38920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38921       };
38922     } catch (...) {
38923       {
38924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38925       };
38926     }
38927   }
38928
38929 }
38930
38931
38932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
38933   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38934   Dali::ResizePolicy::Type arg2 ;
38935   Dali::Dimension::Type arg3 ;
38936
38937   arg1 = (Dali::CustomActorImpl *)jarg1;
38938   arg2 = (Dali::ResizePolicy::Type)jarg2;
38939   arg3 = (Dali::Dimension::Type)jarg3;
38940   {
38941     try {
38942       (arg1)->OnSetResizePolicy(arg2,arg3);
38943     } catch (std::out_of_range& e) {
38944       {
38945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38946       };
38947     } catch (std::exception& e) {
38948       {
38949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38950       };
38951     } catch (Dali::DaliException e) {
38952       {
38953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38954       };
38955     } catch (...) {
38956       {
38957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38958       };
38959     }
38960   }
38961
38962 }
38963
38964
38965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
38966   void * jresult ;
38967   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38968   Dali::Vector3 result;
38969
38970   arg1 = (Dali::CustomActorImpl *)jarg1;
38971   {
38972     try {
38973       result = (arg1)->GetNaturalSize();
38974     } catch (std::out_of_range& e) {
38975       {
38976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38977       };
38978     } catch (std::exception& e) {
38979       {
38980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38981       };
38982     } catch (Dali::DaliException e) {
38983       {
38984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38985       };
38986     } catch (...) {
38987       {
38988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38989       };
38990     }
38991   }
38992
38993   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38994   return jresult;
38995 }
38996
38997
38998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
38999   float jresult ;
39000   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39001   Dali::Actor *arg2 = 0 ;
39002   Dali::Dimension::Type arg3 ;
39003   float result;
39004
39005   arg1 = (Dali::CustomActorImpl *)jarg1;
39006   arg2 = (Dali::Actor *)jarg2;
39007   if (!arg2) {
39008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39009     return 0;
39010   }
39011   arg3 = (Dali::Dimension::Type)jarg3;
39012   {
39013     try {
39014       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39015     } catch (std::out_of_range& e) {
39016       {
39017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39018       };
39019     } catch (std::exception& e) {
39020       {
39021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39022       };
39023     } catch (Dali::DaliException e) {
39024       {
39025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39026       };
39027     } catch (...) {
39028       {
39029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39030       };
39031     }
39032   }
39033
39034   jresult = result;
39035   return jresult;
39036 }
39037
39038
39039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39040   float jresult ;
39041   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39042   float arg2 ;
39043   float result;
39044
39045   arg1 = (Dali::CustomActorImpl *)jarg1;
39046   arg2 = (float)jarg2;
39047   {
39048     try {
39049       result = (float)(arg1)->GetHeightForWidth(arg2);
39050     } catch (std::out_of_range& e) {
39051       {
39052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39053       };
39054     } catch (std::exception& e) {
39055       {
39056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39057       };
39058     } catch (Dali::DaliException e) {
39059       {
39060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39061       };
39062     } catch (...) {
39063       {
39064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39065       };
39066     }
39067   }
39068
39069   jresult = result;
39070   return jresult;
39071 }
39072
39073
39074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39075   float jresult ;
39076   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39077   float arg2 ;
39078   float result;
39079
39080   arg1 = (Dali::CustomActorImpl *)jarg1;
39081   arg2 = (float)jarg2;
39082   {
39083     try {
39084       result = (float)(arg1)->GetWidthForHeight(arg2);
39085     } catch (std::out_of_range& e) {
39086       {
39087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39088       };
39089     } catch (std::exception& e) {
39090       {
39091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39092       };
39093     } catch (Dali::DaliException e) {
39094       {
39095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39096       };
39097     } catch (...) {
39098       {
39099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39100       };
39101     }
39102   }
39103
39104   jresult = result;
39105   return jresult;
39106 }
39107
39108
39109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39110   unsigned int jresult ;
39111   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39112   Dali::Dimension::Type arg2 ;
39113   bool result;
39114
39115   arg1 = (Dali::CustomActorImpl *)jarg1;
39116   arg2 = (Dali::Dimension::Type)jarg2;
39117   {
39118     try {
39119       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39120     } catch (std::out_of_range& e) {
39121       {
39122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39123       };
39124     } catch (std::exception& e) {
39125       {
39126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39127       };
39128     } catch (Dali::DaliException e) {
39129       {
39130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39131       };
39132     } catch (...) {
39133       {
39134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39135       };
39136     }
39137   }
39138
39139   jresult = result;
39140   return jresult;
39141 }
39142
39143
39144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39145   unsigned int jresult ;
39146   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39147   bool result;
39148
39149   arg1 = (Dali::CustomActorImpl *)jarg1;
39150   {
39151     try {
39152       result = (bool)(arg1)->RelayoutDependentOnChildren();
39153     } catch (std::out_of_range& e) {
39154       {
39155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39156       };
39157     } catch (std::exception& e) {
39158       {
39159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39160       };
39161     } catch (Dali::DaliException e) {
39162       {
39163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39164       };
39165     } catch (...) {
39166       {
39167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39168       };
39169     }
39170   }
39171
39172   jresult = result;
39173   return jresult;
39174 }
39175
39176
39177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39178   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39179   Dali::Dimension::Type arg2 ;
39180
39181   arg1 = (Dali::CustomActorImpl *)jarg1;
39182   arg2 = (Dali::Dimension::Type)jarg2;
39183   {
39184     try {
39185       (arg1)->OnCalculateRelayoutSize(arg2);
39186     } catch (std::out_of_range& e) {
39187       {
39188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39189       };
39190     } catch (std::exception& e) {
39191       {
39192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39193       };
39194     } catch (Dali::DaliException e) {
39195       {
39196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39197       };
39198     } catch (...) {
39199       {
39200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39201       };
39202     }
39203   }
39204
39205 }
39206
39207
39208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39209   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39210   float arg2 ;
39211   Dali::Dimension::Type arg3 ;
39212
39213   arg1 = (Dali::CustomActorImpl *)jarg1;
39214   arg2 = (float)jarg2;
39215   arg3 = (Dali::Dimension::Type)jarg3;
39216   {
39217     try {
39218       (arg1)->OnLayoutNegotiated(arg2,arg3);
39219     } catch (std::out_of_range& e) {
39220       {
39221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39222       };
39223     } catch (std::exception& e) {
39224       {
39225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39226       };
39227     } catch (Dali::DaliException e) {
39228       {
39229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39230       };
39231     } catch (...) {
39232       {
39233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39234       };
39235     }
39236   }
39237
39238 }
39239
39240
39241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39242   unsigned int jresult ;
39243   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39244   bool result;
39245
39246   arg1 = (Dali::CustomActorImpl *)jarg1;
39247   {
39248     try {
39249       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39250     } catch (std::out_of_range& e) {
39251       {
39252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39253       };
39254     } catch (std::exception& e) {
39255       {
39256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39257       };
39258     } catch (Dali::DaliException e) {
39259       {
39260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39261       };
39262     } catch (...) {
39263       {
39264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39265       };
39266     }
39267   }
39268
39269   jresult = result;
39270   return jresult;
39271 }
39272
39273
39274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39275   unsigned int jresult ;
39276   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39277   bool result;
39278
39279   arg1 = (Dali::CustomActorImpl *)jarg1;
39280   {
39281     try {
39282       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39283     } catch (std::out_of_range& e) {
39284       {
39285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39286       };
39287     } catch (std::exception& e) {
39288       {
39289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39290       };
39291     } catch (Dali::DaliException e) {
39292       {
39293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39294       };
39295     } catch (...) {
39296       {
39297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39298       };
39299     }
39300   }
39301
39302   jresult = result;
39303   return jresult;
39304 }
39305
39306
39307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39308   unsigned int jresult ;
39309   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39310   bool result;
39311
39312   arg1 = (Dali::CustomActorImpl *)jarg1;
39313   {
39314     try {
39315       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39316     } catch (std::out_of_range& e) {
39317       {
39318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39319       };
39320     } catch (std::exception& e) {
39321       {
39322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39323       };
39324     } catch (Dali::DaliException e) {
39325       {
39326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39327       };
39328     } catch (...) {
39329       {
39330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39331       };
39332     }
39333   }
39334
39335   jresult = result;
39336   return jresult;
39337 }
39338
39339
39340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39341   unsigned int jresult ;
39342   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39343   bool result;
39344
39345   arg1 = (Dali::CustomActorImpl *)jarg1;
39346   {
39347     try {
39348       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39349     } catch (std::out_of_range& e) {
39350       {
39351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39352       };
39353     } catch (std::exception& e) {
39354       {
39355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39356       };
39357     } catch (Dali::DaliException e) {
39358       {
39359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39360       };
39361     } catch (...) {
39362       {
39363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39364       };
39365     }
39366   }
39367
39368   jresult = result;
39369   return jresult;
39370 }
39371
39372
39373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39374   void * jresult ;
39375   Dali::CustomActor *result = 0 ;
39376
39377   {
39378     try {
39379       result = (Dali::CustomActor *)new Dali::CustomActor();
39380     } catch (std::out_of_range& e) {
39381       {
39382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39383       };
39384     } catch (std::exception& e) {
39385       {
39386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39387       };
39388     } catch (Dali::DaliException e) {
39389       {
39390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39391       };
39392     } catch (...) {
39393       {
39394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39395       };
39396     }
39397   }
39398
39399   jresult = (void *)result;
39400   return jresult;
39401 }
39402
39403
39404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39405   void * jresult ;
39406   Dali::BaseHandle arg1 ;
39407   Dali::BaseHandle *argp1 ;
39408   Dali::CustomActor result;
39409
39410   argp1 = (Dali::BaseHandle *)jarg1;
39411   if (!argp1) {
39412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39413     return 0;
39414   }
39415   arg1 = *argp1;
39416   {
39417     try {
39418       result = Dali::CustomActor::DownCast(arg1);
39419     } catch (std::out_of_range& e) {
39420       {
39421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39422       };
39423     } catch (std::exception& e) {
39424       {
39425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39426       };
39427     } catch (Dali::DaliException e) {
39428       {
39429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39430       };
39431     } catch (...) {
39432       {
39433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39434       };
39435     }
39436   }
39437
39438   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39439   return jresult;
39440 }
39441
39442
39443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39444   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39445
39446   arg1 = (Dali::CustomActor *)jarg1;
39447   {
39448     try {
39449       delete arg1;
39450     } catch (std::out_of_range& e) {
39451       {
39452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39453       };
39454     } catch (std::exception& e) {
39455       {
39456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39457       };
39458     } catch (Dali::DaliException e) {
39459       {
39460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39461       };
39462     } catch (...) {
39463       {
39464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39465       };
39466     }
39467   }
39468
39469 }
39470
39471
39472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39473   void * jresult ;
39474   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39475   Dali::CustomActorImpl *result = 0 ;
39476
39477   arg1 = (Dali::CustomActor *)jarg1;
39478   {
39479     try {
39480       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39481     } catch (std::out_of_range& e) {
39482       {
39483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39484       };
39485     } catch (std::exception& e) {
39486       {
39487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39488       };
39489     } catch (Dali::DaliException e) {
39490       {
39491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39492       };
39493     } catch (...) {
39494       {
39495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39496       };
39497     }
39498   }
39499
39500   jresult = (void *)result;
39501   return jresult;
39502 }
39503
39504
39505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39506   void * jresult ;
39507   Dali::CustomActorImpl *arg1 = 0 ;
39508   Dali::CustomActor *result = 0 ;
39509
39510   arg1 = (Dali::CustomActorImpl *)jarg1;
39511   if (!arg1) {
39512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39513     return 0;
39514   }
39515   {
39516     try {
39517       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39518     } catch (std::out_of_range& e) {
39519       {
39520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39521       };
39522     } catch (std::exception& e) {
39523       {
39524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39525       };
39526     } catch (Dali::DaliException e) {
39527       {
39528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39529       };
39530     } catch (...) {
39531       {
39532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39533       };
39534     }
39535   }
39536
39537   jresult = (void *)result;
39538   return jresult;
39539 }
39540
39541
39542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
39543   void * jresult ;
39544   Dali::CustomActor *arg1 = 0 ;
39545   Dali::CustomActor *result = 0 ;
39546
39547   arg1 = (Dali::CustomActor *)jarg1;
39548   if (!arg1) {
39549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39550     return 0;
39551   }
39552   {
39553     try {
39554       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
39555     } catch (std::out_of_range& e) {
39556       {
39557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39558       };
39559     } catch (std::exception& e) {
39560       {
39561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39562       };
39563     } catch (Dali::DaliException e) {
39564       {
39565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39566       };
39567     } catch (...) {
39568       {
39569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39570       };
39571     }
39572   }
39573
39574   jresult = (void *)result;
39575   return jresult;
39576 }
39577
39578
39579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
39580   void * jresult ;
39581   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39582   Dali::CustomActor *arg2 = 0 ;
39583   Dali::CustomActor *result = 0 ;
39584
39585   arg1 = (Dali::CustomActor *)jarg1;
39586   arg2 = (Dali::CustomActor *)jarg2;
39587   if (!arg2) {
39588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39589     return 0;
39590   }
39591   {
39592     try {
39593       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
39594     } catch (std::out_of_range& e) {
39595       {
39596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39597       };
39598     } catch (std::exception& e) {
39599       {
39600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39601       };
39602     } catch (Dali::DaliException e) {
39603       {
39604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39605       };
39606     } catch (...) {
39607       {
39608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39609       };
39610     }
39611   }
39612
39613   jresult = (void *)result;
39614   return jresult;
39615 }
39616
39617
39618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
39619   int jresult ;
39620   int result;
39621
39622   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
39623   jresult = (int)result;
39624   return jresult;
39625 }
39626
39627
39628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
39629   int jresult ;
39630   int result;
39631
39632   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
39633   jresult = (int)result;
39634   return jresult;
39635 }
39636
39637
39638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
39639   int jresult ;
39640   int result;
39641
39642   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
39643   jresult = (int)result;
39644   return jresult;
39645 }
39646
39647
39648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
39649   int jresult ;
39650   int result;
39651
39652   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
39653   jresult = (int)result;
39654   return jresult;
39655 }
39656
39657
39658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
39659   int jresult ;
39660   int result;
39661
39662   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
39663   jresult = (int)result;
39664   return jresult;
39665 }
39666
39667
39668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
39669   int jresult ;
39670   int result;
39671
39672   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
39673   jresult = (int)result;
39674   return jresult;
39675 }
39676
39677
39678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
39679   int jresult ;
39680   int result;
39681
39682   result = (int)Dali::PanGestureDetector::Property::PANNING;
39683   jresult = (int)result;
39684   return jresult;
39685 }
39686
39687
39688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
39689   void * jresult ;
39690   Dali::PanGestureDetector::Property *result = 0 ;
39691
39692   {
39693     try {
39694       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
39695     } catch (std::out_of_range& e) {
39696       {
39697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39698       };
39699     } catch (std::exception& e) {
39700       {
39701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39702       };
39703     } catch (Dali::DaliException e) {
39704       {
39705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39706       };
39707     } catch (...) {
39708       {
39709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39710       };
39711     }
39712   }
39713
39714   jresult = (void *)result;
39715   return jresult;
39716 }
39717
39718
39719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
39720   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
39721
39722   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
39723   {
39724     try {
39725       delete arg1;
39726     } catch (std::out_of_range& e) {
39727       {
39728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39729       };
39730     } catch (std::exception& e) {
39731       {
39732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39733       };
39734     } catch (Dali::DaliException e) {
39735       {
39736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39737       };
39738     } catch (...) {
39739       {
39740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39741       };
39742     }
39743   }
39744
39745 }
39746
39747
39748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
39749   void * jresult ;
39750   Dali::Radian *result = 0 ;
39751
39752   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
39753   jresult = (void *)result;
39754   return jresult;
39755 }
39756
39757
39758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
39759   void * jresult ;
39760   Dali::Radian *result = 0 ;
39761
39762   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
39763   jresult = (void *)result;
39764   return jresult;
39765 }
39766
39767
39768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
39769   void * jresult ;
39770   Dali::Radian *result = 0 ;
39771
39772   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
39773   jresult = (void *)result;
39774   return jresult;
39775 }
39776
39777
39778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
39779   void * jresult ;
39780   Dali::Radian *result = 0 ;
39781
39782   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
39783   jresult = (void *)result;
39784   return jresult;
39785 }
39786
39787
39788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
39789   void * jresult ;
39790   Dali::Radian *result = 0 ;
39791
39792   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
39793   jresult = (void *)result;
39794   return jresult;
39795 }
39796
39797
39798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
39799   void * jresult ;
39800   Dali::Radian *result = 0 ;
39801
39802   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
39803   jresult = (void *)result;
39804   return jresult;
39805 }
39806
39807
39808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
39809   void * jresult ;
39810   Dali::Radian *result = 0 ;
39811
39812   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
39813   jresult = (void *)result;
39814   return jresult;
39815 }
39816
39817
39818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
39819   void * jresult ;
39820   Dali::PanGestureDetector *result = 0 ;
39821
39822   {
39823     try {
39824       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
39825     } catch (std::out_of_range& e) {
39826       {
39827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39828       };
39829     } catch (std::exception& e) {
39830       {
39831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39832       };
39833     } catch (Dali::DaliException e) {
39834       {
39835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39836       };
39837     } catch (...) {
39838       {
39839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39840       };
39841     }
39842   }
39843
39844   jresult = (void *)result;
39845   return jresult;
39846 }
39847
39848
39849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
39850   void * jresult ;
39851   Dali::PanGestureDetector result;
39852
39853   {
39854     try {
39855       result = Dali::PanGestureDetector::New();
39856     } catch (std::out_of_range& e) {
39857       {
39858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39859       };
39860     } catch (std::exception& e) {
39861       {
39862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39863       };
39864     } catch (Dali::DaliException e) {
39865       {
39866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39867       };
39868     } catch (...) {
39869       {
39870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39871       };
39872     }
39873   }
39874
39875   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39876   return jresult;
39877 }
39878
39879
39880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
39881   void * jresult ;
39882   Dali::BaseHandle arg1 ;
39883   Dali::BaseHandle *argp1 ;
39884   Dali::PanGestureDetector result;
39885
39886   argp1 = (Dali::BaseHandle *)jarg1;
39887   if (!argp1) {
39888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39889     return 0;
39890   }
39891   arg1 = *argp1;
39892   {
39893     try {
39894       result = Dali::PanGestureDetector::DownCast(arg1);
39895     } catch (std::out_of_range& e) {
39896       {
39897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39898       };
39899     } catch (std::exception& e) {
39900       {
39901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39902       };
39903     } catch (Dali::DaliException e) {
39904       {
39905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39906       };
39907     } catch (...) {
39908       {
39909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39910       };
39911     }
39912   }
39913
39914   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39915   return jresult;
39916 }
39917
39918
39919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
39920   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39921
39922   arg1 = (Dali::PanGestureDetector *)jarg1;
39923   {
39924     try {
39925       delete arg1;
39926     } catch (std::out_of_range& e) {
39927       {
39928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39929       };
39930     } catch (std::exception& e) {
39931       {
39932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39933       };
39934     } catch (Dali::DaliException e) {
39935       {
39936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39937       };
39938     } catch (...) {
39939       {
39940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39941       };
39942     }
39943   }
39944
39945 }
39946
39947
39948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
39949   void * jresult ;
39950   Dali::PanGestureDetector *arg1 = 0 ;
39951   Dali::PanGestureDetector *result = 0 ;
39952
39953   arg1 = (Dali::PanGestureDetector *)jarg1;
39954   if (!arg1) {
39955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
39956     return 0;
39957   }
39958   {
39959     try {
39960       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
39961     } catch (std::out_of_range& e) {
39962       {
39963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39964       };
39965     } catch (std::exception& e) {
39966       {
39967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39968       };
39969     } catch (Dali::DaliException e) {
39970       {
39971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39972       };
39973     } catch (...) {
39974       {
39975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39976       };
39977     }
39978   }
39979
39980   jresult = (void *)result;
39981   return jresult;
39982 }
39983
39984
39985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
39986   void * jresult ;
39987   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39988   Dali::PanGestureDetector *arg2 = 0 ;
39989   Dali::PanGestureDetector *result = 0 ;
39990
39991   arg1 = (Dali::PanGestureDetector *)jarg1;
39992   arg2 = (Dali::PanGestureDetector *)jarg2;
39993   if (!arg2) {
39994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
39995     return 0;
39996   }
39997   {
39998     try {
39999       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40000     } catch (std::out_of_range& e) {
40001       {
40002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40003       };
40004     } catch (std::exception& e) {
40005       {
40006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40007       };
40008     } catch (Dali::DaliException e) {
40009       {
40010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40011       };
40012     } catch (...) {
40013       {
40014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40015       };
40016     }
40017   }
40018
40019   jresult = (void *)result;
40020   return jresult;
40021 }
40022
40023
40024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40025   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40026   unsigned int arg2 ;
40027
40028   arg1 = (Dali::PanGestureDetector *)jarg1;
40029   arg2 = (unsigned int)jarg2;
40030   {
40031     try {
40032       (arg1)->SetMinimumTouchesRequired(arg2);
40033     } catch (std::out_of_range& e) {
40034       {
40035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40036       };
40037     } catch (std::exception& e) {
40038       {
40039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40040       };
40041     } catch (Dali::DaliException e) {
40042       {
40043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40044       };
40045     } catch (...) {
40046       {
40047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40048       };
40049     }
40050   }
40051
40052 }
40053
40054
40055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40056   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40057   unsigned int arg2 ;
40058
40059   arg1 = (Dali::PanGestureDetector *)jarg1;
40060   arg2 = (unsigned int)jarg2;
40061   {
40062     try {
40063       (arg1)->SetMaximumTouchesRequired(arg2);
40064     } catch (std::out_of_range& e) {
40065       {
40066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40067       };
40068     } catch (std::exception& e) {
40069       {
40070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40071       };
40072     } catch (Dali::DaliException e) {
40073       {
40074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40075       };
40076     } catch (...) {
40077       {
40078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40079       };
40080     }
40081   }
40082
40083 }
40084
40085
40086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40087   unsigned int jresult ;
40088   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40089   unsigned int result;
40090
40091   arg1 = (Dali::PanGestureDetector *)jarg1;
40092   {
40093     try {
40094       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40095     } catch (std::out_of_range& e) {
40096       {
40097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40098       };
40099     } catch (std::exception& e) {
40100       {
40101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40102       };
40103     } catch (Dali::DaliException e) {
40104       {
40105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40106       };
40107     } catch (...) {
40108       {
40109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40110       };
40111     }
40112   }
40113
40114   jresult = result;
40115   return jresult;
40116 }
40117
40118
40119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40120   unsigned int jresult ;
40121   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40122   unsigned int result;
40123
40124   arg1 = (Dali::PanGestureDetector *)jarg1;
40125   {
40126     try {
40127       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40128     } catch (std::out_of_range& e) {
40129       {
40130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40131       };
40132     } catch (std::exception& e) {
40133       {
40134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40135       };
40136     } catch (Dali::DaliException e) {
40137       {
40138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40139       };
40140     } catch (...) {
40141       {
40142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40143       };
40144     }
40145   }
40146
40147   jresult = result;
40148   return jresult;
40149 }
40150
40151
40152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40153   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40154   Dali::Radian arg2 ;
40155   Dali::Radian arg3 ;
40156   Dali::Radian *argp2 ;
40157   Dali::Radian *argp3 ;
40158
40159   arg1 = (Dali::PanGestureDetector *)jarg1;
40160   argp2 = (Dali::Radian *)jarg2;
40161   if (!argp2) {
40162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40163     return ;
40164   }
40165   arg2 = *argp2;
40166   argp3 = (Dali::Radian *)jarg3;
40167   if (!argp3) {
40168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40169     return ;
40170   }
40171   arg3 = *argp3;
40172   {
40173     try {
40174       (arg1)->AddAngle(arg2,arg3);
40175     } catch (std::out_of_range& e) {
40176       {
40177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40178       };
40179     } catch (std::exception& e) {
40180       {
40181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40182       };
40183     } catch (Dali::DaliException e) {
40184       {
40185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40186       };
40187     } catch (...) {
40188       {
40189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40190       };
40191     }
40192   }
40193
40194 }
40195
40196
40197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40198   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40199   Dali::Radian arg2 ;
40200   Dali::Radian *argp2 ;
40201
40202   arg1 = (Dali::PanGestureDetector *)jarg1;
40203   argp2 = (Dali::Radian *)jarg2;
40204   if (!argp2) {
40205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40206     return ;
40207   }
40208   arg2 = *argp2;
40209   {
40210     try {
40211       (arg1)->AddAngle(arg2);
40212     } catch (std::out_of_range& e) {
40213       {
40214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40215       };
40216     } catch (std::exception& e) {
40217       {
40218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40219       };
40220     } catch (Dali::DaliException e) {
40221       {
40222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40223       };
40224     } catch (...) {
40225       {
40226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40227       };
40228     }
40229   }
40230
40231 }
40232
40233
40234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40235   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40236   Dali::Radian arg2 ;
40237   Dali::Radian arg3 ;
40238   Dali::Radian *argp2 ;
40239   Dali::Radian *argp3 ;
40240
40241   arg1 = (Dali::PanGestureDetector *)jarg1;
40242   argp2 = (Dali::Radian *)jarg2;
40243   if (!argp2) {
40244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40245     return ;
40246   }
40247   arg2 = *argp2;
40248   argp3 = (Dali::Radian *)jarg3;
40249   if (!argp3) {
40250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40251     return ;
40252   }
40253   arg3 = *argp3;
40254   {
40255     try {
40256       (arg1)->AddDirection(arg2,arg3);
40257     } catch (std::out_of_range& e) {
40258       {
40259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40260       };
40261     } catch (std::exception& e) {
40262       {
40263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40264       };
40265     } catch (Dali::DaliException e) {
40266       {
40267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40268       };
40269     } catch (...) {
40270       {
40271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40272       };
40273     }
40274   }
40275
40276 }
40277
40278
40279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40280   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40281   Dali::Radian arg2 ;
40282   Dali::Radian *argp2 ;
40283
40284   arg1 = (Dali::PanGestureDetector *)jarg1;
40285   argp2 = (Dali::Radian *)jarg2;
40286   if (!argp2) {
40287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40288     return ;
40289   }
40290   arg2 = *argp2;
40291   {
40292     try {
40293       (arg1)->AddDirection(arg2);
40294     } catch (std::out_of_range& e) {
40295       {
40296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40297       };
40298     } catch (std::exception& e) {
40299       {
40300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40301       };
40302     } catch (Dali::DaliException e) {
40303       {
40304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40305       };
40306     } catch (...) {
40307       {
40308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40309       };
40310     }
40311   }
40312
40313 }
40314
40315
40316 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40317   unsigned long jresult ;
40318   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40319   size_t result;
40320
40321   arg1 = (Dali::PanGestureDetector *)jarg1;
40322   {
40323     try {
40324       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40325     } catch (std::out_of_range& e) {
40326       {
40327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40328       };
40329     } catch (std::exception& e) {
40330       {
40331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40332       };
40333     } catch (Dali::DaliException e) {
40334       {
40335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40336       };
40337     } catch (...) {
40338       {
40339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40340       };
40341     }
40342   }
40343
40344   jresult = (unsigned long)result;
40345   return jresult;
40346 }
40347
40348
40349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40350   void * jresult ;
40351   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40352   size_t arg2 ;
40353   Dali::PanGestureDetector::AngleThresholdPair result;
40354
40355   arg1 = (Dali::PanGestureDetector *)jarg1;
40356   arg2 = (size_t)jarg2;
40357   {
40358     try {
40359       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40360     } catch (std::out_of_range& e) {
40361       {
40362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40363       };
40364     } catch (std::exception& e) {
40365       {
40366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40367       };
40368     } catch (Dali::DaliException e) {
40369       {
40370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40371       };
40372     } catch (...) {
40373       {
40374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40375       };
40376     }
40377   }
40378
40379   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40380   return jresult;
40381 }
40382
40383
40384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40385   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40386
40387   arg1 = (Dali::PanGestureDetector *)jarg1;
40388   {
40389     try {
40390       (arg1)->ClearAngles();
40391     } catch (std::out_of_range& e) {
40392       {
40393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40394       };
40395     } catch (std::exception& e) {
40396       {
40397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40398       };
40399     } catch (Dali::DaliException e) {
40400       {
40401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40402       };
40403     } catch (...) {
40404       {
40405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40406       };
40407     }
40408   }
40409
40410 }
40411
40412
40413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40414   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40415   Dali::Radian arg2 ;
40416   Dali::Radian *argp2 ;
40417
40418   arg1 = (Dali::PanGestureDetector *)jarg1;
40419   argp2 = (Dali::Radian *)jarg2;
40420   if (!argp2) {
40421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40422     return ;
40423   }
40424   arg2 = *argp2;
40425   {
40426     try {
40427       (arg1)->RemoveAngle(arg2);
40428     } catch (std::out_of_range& e) {
40429       {
40430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40431       };
40432     } catch (std::exception& e) {
40433       {
40434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40435       };
40436     } catch (Dali::DaliException e) {
40437       {
40438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40439       };
40440     } catch (...) {
40441       {
40442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40443       };
40444     }
40445   }
40446
40447 }
40448
40449
40450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40451   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40452   Dali::Radian arg2 ;
40453   Dali::Radian *argp2 ;
40454
40455   arg1 = (Dali::PanGestureDetector *)jarg1;
40456   argp2 = (Dali::Radian *)jarg2;
40457   if (!argp2) {
40458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40459     return ;
40460   }
40461   arg2 = *argp2;
40462   {
40463     try {
40464       (arg1)->RemoveDirection(arg2);
40465     } catch (std::out_of_range& e) {
40466       {
40467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40468       };
40469     } catch (std::exception& e) {
40470       {
40471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40472       };
40473     } catch (Dali::DaliException e) {
40474       {
40475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40476       };
40477     } catch (...) {
40478       {
40479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40480       };
40481     }
40482   }
40483
40484 }
40485
40486
40487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40488   void * jresult ;
40489   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40490   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40491
40492   arg1 = (Dali::PanGestureDetector *)jarg1;
40493   {
40494     try {
40495       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
40496     } catch (std::out_of_range& e) {
40497       {
40498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40499       };
40500     } catch (std::exception& e) {
40501       {
40502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40503       };
40504     } catch (Dali::DaliException e) {
40505       {
40506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40507       };
40508     } catch (...) {
40509       {
40510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40511       };
40512     }
40513   }
40514
40515   jresult = (void *)result;
40516   return jresult;
40517 }
40518
40519
40520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
40521   Dali::PanGesture *arg1 = 0 ;
40522
40523   arg1 = (Dali::PanGesture *)jarg1;
40524   if (!arg1) {
40525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40526     return ;
40527   }
40528   {
40529     try {
40530       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40531     } catch (std::out_of_range& e) {
40532       {
40533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40534       };
40535     } catch (std::exception& e) {
40536       {
40537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40538       };
40539     } catch (Dali::DaliException e) {
40540       {
40541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40542       };
40543     } catch (...) {
40544       {
40545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40546       };
40547     }
40548   }
40549
40550 }
40551
40552
40553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
40554   void * jresult ;
40555   Dali::PanGesture *result = 0 ;
40556
40557   {
40558     try {
40559       result = (Dali::PanGesture *)new Dali::PanGesture();
40560     } catch (std::out_of_range& e) {
40561       {
40562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40563       };
40564     } catch (std::exception& e) {
40565       {
40566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40567       };
40568     } catch (Dali::DaliException e) {
40569       {
40570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40571       };
40572     } catch (...) {
40573       {
40574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40575       };
40576     }
40577   }
40578
40579   jresult = (void *)result;
40580   return jresult;
40581 }
40582
40583
40584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
40585   void * jresult ;
40586   Dali::Gesture::State arg1 ;
40587   Dali::PanGesture *result = 0 ;
40588
40589   arg1 = (Dali::Gesture::State)jarg1;
40590   {
40591     try {
40592       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
40593     } catch (std::out_of_range& e) {
40594       {
40595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40596       };
40597     } catch (std::exception& e) {
40598       {
40599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40600       };
40601     } catch (Dali::DaliException e) {
40602       {
40603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40604       };
40605     } catch (...) {
40606       {
40607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40608       };
40609     }
40610   }
40611
40612   jresult = (void *)result;
40613   return jresult;
40614 }
40615
40616
40617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
40618   void * jresult ;
40619   Dali::PanGesture *arg1 = 0 ;
40620   Dali::PanGesture *result = 0 ;
40621
40622   arg1 = (Dali::PanGesture *)jarg1;
40623   if (!arg1) {
40624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40625     return 0;
40626   }
40627   {
40628     try {
40629       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
40630     } catch (std::out_of_range& e) {
40631       {
40632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40633       };
40634     } catch (std::exception& e) {
40635       {
40636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40637       };
40638     } catch (Dali::DaliException e) {
40639       {
40640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40641       };
40642     } catch (...) {
40643       {
40644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40645       };
40646     }
40647   }
40648
40649   jresult = (void *)result;
40650   return jresult;
40651 }
40652
40653
40654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
40655   void * jresult ;
40656   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40657   Dali::PanGesture *arg2 = 0 ;
40658   Dali::PanGesture *result = 0 ;
40659
40660   arg1 = (Dali::PanGesture *)jarg1;
40661   arg2 = (Dali::PanGesture *)jarg2;
40662   if (!arg2) {
40663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40664     return 0;
40665   }
40666   {
40667     try {
40668       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
40669     } catch (std::out_of_range& e) {
40670       {
40671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40672       };
40673     } catch (std::exception& e) {
40674       {
40675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40676       };
40677     } catch (Dali::DaliException e) {
40678       {
40679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40680       };
40681     } catch (...) {
40682       {
40683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40684       };
40685     }
40686   }
40687
40688   jresult = (void *)result;
40689   return jresult;
40690 }
40691
40692
40693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
40694   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40695
40696   arg1 = (Dali::PanGesture *)jarg1;
40697   {
40698     try {
40699       delete arg1;
40700     } catch (std::out_of_range& e) {
40701       {
40702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40703       };
40704     } catch (std::exception& e) {
40705       {
40706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40707       };
40708     } catch (Dali::DaliException e) {
40709       {
40710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40711       };
40712     } catch (...) {
40713       {
40714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40715       };
40716     }
40717   }
40718
40719 }
40720
40721
40722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
40723   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40724   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40725
40726   arg1 = (Dali::PanGesture *)jarg1;
40727   arg2 = (Dali::Vector2 *)jarg2;
40728   if (arg1) (arg1)->velocity = *arg2;
40729 }
40730
40731
40732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
40733   void * jresult ;
40734   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40735   Dali::Vector2 *result = 0 ;
40736
40737   arg1 = (Dali::PanGesture *)jarg1;
40738   result = (Dali::Vector2 *)& ((arg1)->velocity);
40739   jresult = (void *)result;
40740   return jresult;
40741 }
40742
40743
40744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
40745   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40746   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40747
40748   arg1 = (Dali::PanGesture *)jarg1;
40749   arg2 = (Dali::Vector2 *)jarg2;
40750   if (arg1) (arg1)->displacement = *arg2;
40751 }
40752
40753
40754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
40755   void * jresult ;
40756   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40757   Dali::Vector2 *result = 0 ;
40758
40759   arg1 = (Dali::PanGesture *)jarg1;
40760   result = (Dali::Vector2 *)& ((arg1)->displacement);
40761   jresult = (void *)result;
40762   return jresult;
40763 }
40764
40765
40766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
40767   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40768   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40769
40770   arg1 = (Dali::PanGesture *)jarg1;
40771   arg2 = (Dali::Vector2 *)jarg2;
40772   if (arg1) (arg1)->position = *arg2;
40773 }
40774
40775
40776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
40777   void * jresult ;
40778   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40779   Dali::Vector2 *result = 0 ;
40780
40781   arg1 = (Dali::PanGesture *)jarg1;
40782   result = (Dali::Vector2 *)& ((arg1)->position);
40783   jresult = (void *)result;
40784   return jresult;
40785 }
40786
40787
40788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
40789   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40790   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40791
40792   arg1 = (Dali::PanGesture *)jarg1;
40793   arg2 = (Dali::Vector2 *)jarg2;
40794   if (arg1) (arg1)->screenVelocity = *arg2;
40795 }
40796
40797
40798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
40799   void * jresult ;
40800   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40801   Dali::Vector2 *result = 0 ;
40802
40803   arg1 = (Dali::PanGesture *)jarg1;
40804   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
40805   jresult = (void *)result;
40806   return jresult;
40807 }
40808
40809
40810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
40811   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40812   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40813
40814   arg1 = (Dali::PanGesture *)jarg1;
40815   arg2 = (Dali::Vector2 *)jarg2;
40816   if (arg1) (arg1)->screenDisplacement = *arg2;
40817 }
40818
40819
40820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
40821   void * jresult ;
40822   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40823   Dali::Vector2 *result = 0 ;
40824
40825   arg1 = (Dali::PanGesture *)jarg1;
40826   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
40827   jresult = (void *)result;
40828   return jresult;
40829 }
40830
40831
40832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
40833   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40834   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40835
40836   arg1 = (Dali::PanGesture *)jarg1;
40837   arg2 = (Dali::Vector2 *)jarg2;
40838   if (arg1) (arg1)->screenPosition = *arg2;
40839 }
40840
40841
40842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
40843   void * jresult ;
40844   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40845   Dali::Vector2 *result = 0 ;
40846
40847   arg1 = (Dali::PanGesture *)jarg1;
40848   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
40849   jresult = (void *)result;
40850   return jresult;
40851 }
40852
40853
40854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
40855   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40856   unsigned int arg2 ;
40857
40858   arg1 = (Dali::PanGesture *)jarg1;
40859   arg2 = (unsigned int)jarg2;
40860   if (arg1) (arg1)->numberOfTouches = arg2;
40861 }
40862
40863
40864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
40865   unsigned int jresult ;
40866   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40867   unsigned int result;
40868
40869   arg1 = (Dali::PanGesture *)jarg1;
40870   result = (unsigned int) ((arg1)->numberOfTouches);
40871   jresult = result;
40872   return jresult;
40873 }
40874
40875
40876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
40877   float jresult ;
40878   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40879   float result;
40880
40881   arg1 = (Dali::PanGesture *)jarg1;
40882   {
40883     try {
40884       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
40885     } catch (std::out_of_range& e) {
40886       {
40887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40888       };
40889     } catch (std::exception& e) {
40890       {
40891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40892       };
40893     } catch (Dali::DaliException e) {
40894       {
40895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40896       };
40897     } catch (...) {
40898       {
40899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40900       };
40901     }
40902   }
40903
40904   jresult = result;
40905   return jresult;
40906 }
40907
40908
40909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
40910   float jresult ;
40911   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40912   float result;
40913
40914   arg1 = (Dali::PanGesture *)jarg1;
40915   {
40916     try {
40917       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
40918     } catch (std::out_of_range& e) {
40919       {
40920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40921       };
40922     } catch (std::exception& e) {
40923       {
40924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40925       };
40926     } catch (Dali::DaliException e) {
40927       {
40928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40929       };
40930     } catch (...) {
40931       {
40932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40933       };
40934     }
40935   }
40936
40937   jresult = result;
40938   return jresult;
40939 }
40940
40941
40942 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
40943   float jresult ;
40944   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40945   float result;
40946
40947   arg1 = (Dali::PanGesture *)jarg1;
40948   {
40949     try {
40950       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
40951     } catch (std::out_of_range& e) {
40952       {
40953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40954       };
40955     } catch (std::exception& e) {
40956       {
40957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40958       };
40959     } catch (Dali::DaliException e) {
40960       {
40961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40962       };
40963     } catch (...) {
40964       {
40965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40966       };
40967     }
40968   }
40969
40970   jresult = result;
40971   return jresult;
40972 }
40973
40974
40975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
40976   float jresult ;
40977   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40978   float result;
40979
40980   arg1 = (Dali::PanGesture *)jarg1;
40981   {
40982     try {
40983       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
40984     } catch (std::out_of_range& e) {
40985       {
40986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40987       };
40988     } catch (std::exception& e) {
40989       {
40990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40991       };
40992     } catch (Dali::DaliException e) {
40993       {
40994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40995       };
40996     } catch (...) {
40997       {
40998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40999       };
41000     }
41001   }
41002
41003   jresult = result;
41004   return jresult;
41005 }
41006
41007
41008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41009   void * jresult ;
41010   Dali::PinchGestureDetector *result = 0 ;
41011
41012   {
41013     try {
41014       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41015     } catch (std::out_of_range& e) {
41016       {
41017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41018       };
41019     } catch (std::exception& e) {
41020       {
41021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41022       };
41023     } catch (Dali::DaliException e) {
41024       {
41025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41026       };
41027     } catch (...) {
41028       {
41029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41030       };
41031     }
41032   }
41033
41034   jresult = (void *)result;
41035   return jresult;
41036 }
41037
41038
41039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41040   void * jresult ;
41041   Dali::PinchGestureDetector result;
41042
41043   {
41044     try {
41045       result = Dali::PinchGestureDetector::New();
41046     } catch (std::out_of_range& e) {
41047       {
41048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41049       };
41050     } catch (std::exception& e) {
41051       {
41052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41053       };
41054     } catch (Dali::DaliException e) {
41055       {
41056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41057       };
41058     } catch (...) {
41059       {
41060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41061       };
41062     }
41063   }
41064
41065   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41066   return jresult;
41067 }
41068
41069
41070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41071   void * jresult ;
41072   Dali::BaseHandle arg1 ;
41073   Dali::BaseHandle *argp1 ;
41074   Dali::PinchGestureDetector result;
41075
41076   argp1 = (Dali::BaseHandle *)jarg1;
41077   if (!argp1) {
41078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41079     return 0;
41080   }
41081   arg1 = *argp1;
41082   {
41083     try {
41084       result = Dali::PinchGestureDetector::DownCast(arg1);
41085     } catch (std::out_of_range& e) {
41086       {
41087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41088       };
41089     } catch (std::exception& e) {
41090       {
41091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41092       };
41093     } catch (Dali::DaliException e) {
41094       {
41095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41096       };
41097     } catch (...) {
41098       {
41099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41100       };
41101     }
41102   }
41103
41104   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41105   return jresult;
41106 }
41107
41108
41109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41110   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41111
41112   arg1 = (Dali::PinchGestureDetector *)jarg1;
41113   {
41114     try {
41115       delete arg1;
41116     } catch (std::out_of_range& e) {
41117       {
41118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41119       };
41120     } catch (std::exception& e) {
41121       {
41122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41123       };
41124     } catch (Dali::DaliException e) {
41125       {
41126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41127       };
41128     } catch (...) {
41129       {
41130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41131       };
41132     }
41133   }
41134
41135 }
41136
41137
41138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41139   void * jresult ;
41140   Dali::PinchGestureDetector *arg1 = 0 ;
41141   Dali::PinchGestureDetector *result = 0 ;
41142
41143   arg1 = (Dali::PinchGestureDetector *)jarg1;
41144   if (!arg1) {
41145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41146     return 0;
41147   }
41148   {
41149     try {
41150       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41151     } catch (std::out_of_range& e) {
41152       {
41153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41154       };
41155     } catch (std::exception& e) {
41156       {
41157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41158       };
41159     } catch (Dali::DaliException e) {
41160       {
41161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41162       };
41163     } catch (...) {
41164       {
41165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41166       };
41167     }
41168   }
41169
41170   jresult = (void *)result;
41171   return jresult;
41172 }
41173
41174
41175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41176   void * jresult ;
41177   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41178   Dali::PinchGestureDetector *arg2 = 0 ;
41179   Dali::PinchGestureDetector *result = 0 ;
41180
41181   arg1 = (Dali::PinchGestureDetector *)jarg1;
41182   arg2 = (Dali::PinchGestureDetector *)jarg2;
41183   if (!arg2) {
41184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41185     return 0;
41186   }
41187   {
41188     try {
41189       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41190     } catch (std::out_of_range& e) {
41191       {
41192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41193       };
41194     } catch (std::exception& e) {
41195       {
41196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41197       };
41198     } catch (Dali::DaliException e) {
41199       {
41200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41201       };
41202     } catch (...) {
41203       {
41204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41205       };
41206     }
41207   }
41208
41209   jresult = (void *)result;
41210   return jresult;
41211 }
41212
41213
41214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41215   void * jresult ;
41216   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41217   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41218
41219   arg1 = (Dali::PinchGestureDetector *)jarg1;
41220   {
41221     try {
41222       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41223     } catch (std::out_of_range& e) {
41224       {
41225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41226       };
41227     } catch (std::exception& e) {
41228       {
41229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41230       };
41231     } catch (Dali::DaliException e) {
41232       {
41233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41234       };
41235     } catch (...) {
41236       {
41237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41238       };
41239     }
41240   }
41241
41242   jresult = (void *)result;
41243   return jresult;
41244 }
41245
41246
41247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41248   void * jresult ;
41249   Dali::Gesture::State arg1 ;
41250   Dali::PinchGesture *result = 0 ;
41251
41252   arg1 = (Dali::Gesture::State)jarg1;
41253   {
41254     try {
41255       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41256     } catch (std::out_of_range& e) {
41257       {
41258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41259       };
41260     } catch (std::exception& e) {
41261       {
41262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41263       };
41264     } catch (Dali::DaliException e) {
41265       {
41266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41267       };
41268     } catch (...) {
41269       {
41270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41271       };
41272     }
41273   }
41274
41275   jresult = (void *)result;
41276   return jresult;
41277 }
41278
41279
41280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41281   void * jresult ;
41282   Dali::PinchGesture *arg1 = 0 ;
41283   Dali::PinchGesture *result = 0 ;
41284
41285   arg1 = (Dali::PinchGesture *)jarg1;
41286   if (!arg1) {
41287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41288     return 0;
41289   }
41290   {
41291     try {
41292       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41293     } catch (std::out_of_range& e) {
41294       {
41295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41296       };
41297     } catch (std::exception& e) {
41298       {
41299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41300       };
41301     } catch (Dali::DaliException e) {
41302       {
41303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41304       };
41305     } catch (...) {
41306       {
41307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41308       };
41309     }
41310   }
41311
41312   jresult = (void *)result;
41313   return jresult;
41314 }
41315
41316
41317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41318   void * jresult ;
41319   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41320   Dali::PinchGesture *arg2 = 0 ;
41321   Dali::PinchGesture *result = 0 ;
41322
41323   arg1 = (Dali::PinchGesture *)jarg1;
41324   arg2 = (Dali::PinchGesture *)jarg2;
41325   if (!arg2) {
41326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41327     return 0;
41328   }
41329   {
41330     try {
41331       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41332     } catch (std::out_of_range& e) {
41333       {
41334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41335       };
41336     } catch (std::exception& e) {
41337       {
41338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41339       };
41340     } catch (Dali::DaliException e) {
41341       {
41342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41343       };
41344     } catch (...) {
41345       {
41346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41347       };
41348     }
41349   }
41350
41351   jresult = (void *)result;
41352   return jresult;
41353 }
41354
41355
41356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41357   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41358
41359   arg1 = (Dali::PinchGesture *)jarg1;
41360   {
41361     try {
41362       delete arg1;
41363     } catch (std::out_of_range& e) {
41364       {
41365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41366       };
41367     } catch (std::exception& e) {
41368       {
41369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41370       };
41371     } catch (Dali::DaliException e) {
41372       {
41373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41374       };
41375     } catch (...) {
41376       {
41377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41378       };
41379     }
41380   }
41381
41382 }
41383
41384
41385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41386   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41387   float arg2 ;
41388
41389   arg1 = (Dali::PinchGesture *)jarg1;
41390   arg2 = (float)jarg2;
41391   if (arg1) (arg1)->scale = arg2;
41392 }
41393
41394
41395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41396   float jresult ;
41397   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41398   float result;
41399
41400   arg1 = (Dali::PinchGesture *)jarg1;
41401   result = (float) ((arg1)->scale);
41402   jresult = result;
41403   return jresult;
41404 }
41405
41406
41407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41408   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41409   float arg2 ;
41410
41411   arg1 = (Dali::PinchGesture *)jarg1;
41412   arg2 = (float)jarg2;
41413   if (arg1) (arg1)->speed = arg2;
41414 }
41415
41416
41417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41418   float jresult ;
41419   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41420   float result;
41421
41422   arg1 = (Dali::PinchGesture *)jarg1;
41423   result = (float) ((arg1)->speed);
41424   jresult = result;
41425   return jresult;
41426 }
41427
41428
41429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41430   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41431   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41432
41433   arg1 = (Dali::PinchGesture *)jarg1;
41434   arg2 = (Dali::Vector2 *)jarg2;
41435   if (arg1) (arg1)->screenCenterPoint = *arg2;
41436 }
41437
41438
41439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41440   void * jresult ;
41441   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41442   Dali::Vector2 *result = 0 ;
41443
41444   arg1 = (Dali::PinchGesture *)jarg1;
41445   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41446   jresult = (void *)result;
41447   return jresult;
41448 }
41449
41450
41451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41452   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41453   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41454
41455   arg1 = (Dali::PinchGesture *)jarg1;
41456   arg2 = (Dali::Vector2 *)jarg2;
41457   if (arg1) (arg1)->localCenterPoint = *arg2;
41458 }
41459
41460
41461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41462   void * jresult ;
41463   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41464   Dali::Vector2 *result = 0 ;
41465
41466   arg1 = (Dali::PinchGesture *)jarg1;
41467   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41468   jresult = (void *)result;
41469   return jresult;
41470 }
41471
41472
41473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41474   void * jresult ;
41475   Dali::TapGestureDetector *result = 0 ;
41476
41477   {
41478     try {
41479       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
41480     } catch (std::out_of_range& e) {
41481       {
41482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41483       };
41484     } catch (std::exception& e) {
41485       {
41486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41487       };
41488     } catch (Dali::DaliException e) {
41489       {
41490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41491       };
41492     } catch (...) {
41493       {
41494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41495       };
41496     }
41497   }
41498
41499   jresult = (void *)result;
41500   return jresult;
41501 }
41502
41503
41504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41505   void * jresult ;
41506   Dali::TapGestureDetector result;
41507
41508   {
41509     try {
41510       result = Dali::TapGestureDetector::New();
41511     } catch (std::out_of_range& e) {
41512       {
41513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41514       };
41515     } catch (std::exception& e) {
41516       {
41517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41518       };
41519     } catch (Dali::DaliException e) {
41520       {
41521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41522       };
41523     } catch (...) {
41524       {
41525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41526       };
41527     }
41528   }
41529
41530   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41531   return jresult;
41532 }
41533
41534
41535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41536   void * jresult ;
41537   unsigned int arg1 ;
41538   Dali::TapGestureDetector result;
41539
41540   arg1 = (unsigned int)jarg1;
41541   {
41542     try {
41543       result = Dali::TapGestureDetector::New(arg1);
41544     } catch (std::out_of_range& e) {
41545       {
41546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41547       };
41548     } catch (std::exception& e) {
41549       {
41550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41551       };
41552     } catch (Dali::DaliException e) {
41553       {
41554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41555       };
41556     } catch (...) {
41557       {
41558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41559       };
41560     }
41561   }
41562
41563   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41564   return jresult;
41565 }
41566
41567
41568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
41569   void * jresult ;
41570   Dali::BaseHandle arg1 ;
41571   Dali::BaseHandle *argp1 ;
41572   Dali::TapGestureDetector result;
41573
41574   argp1 = (Dali::BaseHandle *)jarg1;
41575   if (!argp1) {
41576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41577     return 0;
41578   }
41579   arg1 = *argp1;
41580   {
41581     try {
41582       result = Dali::TapGestureDetector::DownCast(arg1);
41583     } catch (std::out_of_range& e) {
41584       {
41585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41586       };
41587     } catch (std::exception& e) {
41588       {
41589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41590       };
41591     } catch (Dali::DaliException e) {
41592       {
41593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41594       };
41595     } catch (...) {
41596       {
41597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41598       };
41599     }
41600   }
41601
41602   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41603   return jresult;
41604 }
41605
41606
41607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
41608   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41609
41610   arg1 = (Dali::TapGestureDetector *)jarg1;
41611   {
41612     try {
41613       delete arg1;
41614     } catch (std::out_of_range& e) {
41615       {
41616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41617       };
41618     } catch (std::exception& e) {
41619       {
41620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41621       };
41622     } catch (Dali::DaliException e) {
41623       {
41624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41625       };
41626     } catch (...) {
41627       {
41628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41629       };
41630     }
41631   }
41632
41633 }
41634
41635
41636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
41637   void * jresult ;
41638   Dali::TapGestureDetector *arg1 = 0 ;
41639   Dali::TapGestureDetector *result = 0 ;
41640
41641   arg1 = (Dali::TapGestureDetector *)jarg1;
41642   if (!arg1) {
41643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41644     return 0;
41645   }
41646   {
41647     try {
41648       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
41649     } catch (std::out_of_range& e) {
41650       {
41651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41652       };
41653     } catch (std::exception& e) {
41654       {
41655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41656       };
41657     } catch (Dali::DaliException e) {
41658       {
41659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41660       };
41661     } catch (...) {
41662       {
41663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41664       };
41665     }
41666   }
41667
41668   jresult = (void *)result;
41669   return jresult;
41670 }
41671
41672
41673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
41674   void * jresult ;
41675   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41676   Dali::TapGestureDetector *arg2 = 0 ;
41677   Dali::TapGestureDetector *result = 0 ;
41678
41679   arg1 = (Dali::TapGestureDetector *)jarg1;
41680   arg2 = (Dali::TapGestureDetector *)jarg2;
41681   if (!arg2) {
41682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41683     return 0;
41684   }
41685   {
41686     try {
41687       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
41688     } catch (std::out_of_range& e) {
41689       {
41690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41691       };
41692     } catch (std::exception& e) {
41693       {
41694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41695       };
41696     } catch (Dali::DaliException e) {
41697       {
41698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41699       };
41700     } catch (...) {
41701       {
41702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41703       };
41704     }
41705   }
41706
41707   jresult = (void *)result;
41708   return jresult;
41709 }
41710
41711
41712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
41713   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41714   unsigned int arg2 ;
41715
41716   arg1 = (Dali::TapGestureDetector *)jarg1;
41717   arg2 = (unsigned int)jarg2;
41718   {
41719     try {
41720       (arg1)->SetMinimumTapsRequired(arg2);
41721     } catch (std::out_of_range& e) {
41722       {
41723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41724       };
41725     } catch (std::exception& e) {
41726       {
41727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41728       };
41729     } catch (Dali::DaliException e) {
41730       {
41731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41732       };
41733     } catch (...) {
41734       {
41735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41736       };
41737     }
41738   }
41739
41740 }
41741
41742
41743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
41744   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41745   unsigned int arg2 ;
41746
41747   arg1 = (Dali::TapGestureDetector *)jarg1;
41748   arg2 = (unsigned int)jarg2;
41749   {
41750     try {
41751       (arg1)->SetMaximumTapsRequired(arg2);
41752     } catch (std::out_of_range& e) {
41753       {
41754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41755       };
41756     } catch (std::exception& e) {
41757       {
41758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41759       };
41760     } catch (Dali::DaliException e) {
41761       {
41762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41763       };
41764     } catch (...) {
41765       {
41766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41767       };
41768     }
41769   }
41770
41771 }
41772
41773
41774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
41775   unsigned int jresult ;
41776   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41777   unsigned int result;
41778
41779   arg1 = (Dali::TapGestureDetector *)jarg1;
41780   {
41781     try {
41782       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
41783     } catch (std::out_of_range& e) {
41784       {
41785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41786       };
41787     } catch (std::exception& e) {
41788       {
41789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41790       };
41791     } catch (Dali::DaliException e) {
41792       {
41793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41794       };
41795     } catch (...) {
41796       {
41797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41798       };
41799     }
41800   }
41801
41802   jresult = result;
41803   return jresult;
41804 }
41805
41806
41807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
41808   unsigned int jresult ;
41809   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41810   unsigned int result;
41811
41812   arg1 = (Dali::TapGestureDetector *)jarg1;
41813   {
41814     try {
41815       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
41816     } catch (std::out_of_range& e) {
41817       {
41818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41819       };
41820     } catch (std::exception& e) {
41821       {
41822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41823       };
41824     } catch (Dali::DaliException e) {
41825       {
41826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41827       };
41828     } catch (...) {
41829       {
41830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41831       };
41832     }
41833   }
41834
41835   jresult = result;
41836   return jresult;
41837 }
41838
41839
41840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
41841   void * jresult ;
41842   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41843   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
41844
41845   arg1 = (Dali::TapGestureDetector *)jarg1;
41846   {
41847     try {
41848       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41849     } catch (std::out_of_range& e) {
41850       {
41851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41852       };
41853     } catch (std::exception& e) {
41854       {
41855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41856       };
41857     } catch (Dali::DaliException e) {
41858       {
41859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41860       };
41861     } catch (...) {
41862       {
41863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41864       };
41865     }
41866   }
41867
41868   jresult = (void *)result;
41869   return jresult;
41870 }
41871
41872
41873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
41874   void * jresult ;
41875   Dali::TapGesture *result = 0 ;
41876
41877   {
41878     try {
41879       result = (Dali::TapGesture *)new Dali::TapGesture();
41880     } catch (std::out_of_range& e) {
41881       {
41882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41883       };
41884     } catch (std::exception& e) {
41885       {
41886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41887       };
41888     } catch (Dali::DaliException e) {
41889       {
41890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41891       };
41892     } catch (...) {
41893       {
41894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41895       };
41896     }
41897   }
41898
41899   jresult = (void *)result;
41900   return jresult;
41901 }
41902
41903
41904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
41905   void * jresult ;
41906   Dali::TapGesture *arg1 = 0 ;
41907   Dali::TapGesture *result = 0 ;
41908
41909   arg1 = (Dali::TapGesture *)jarg1;
41910   if (!arg1) {
41911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
41912     return 0;
41913   }
41914   {
41915     try {
41916       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
41917     } catch (std::out_of_range& e) {
41918       {
41919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41920       };
41921     } catch (std::exception& e) {
41922       {
41923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41924       };
41925     } catch (Dali::DaliException e) {
41926       {
41927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41928       };
41929     } catch (...) {
41930       {
41931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41932       };
41933     }
41934   }
41935
41936   jresult = (void *)result;
41937   return jresult;
41938 }
41939
41940
41941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
41942   void * jresult ;
41943   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41944   Dali::TapGesture *arg2 = 0 ;
41945   Dali::TapGesture *result = 0 ;
41946
41947   arg1 = (Dali::TapGesture *)jarg1;
41948   arg2 = (Dali::TapGesture *)jarg2;
41949   if (!arg2) {
41950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
41951     return 0;
41952   }
41953   {
41954     try {
41955       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
41956     } catch (std::out_of_range& e) {
41957       {
41958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41959       };
41960     } catch (std::exception& e) {
41961       {
41962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41963       };
41964     } catch (Dali::DaliException e) {
41965       {
41966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41967       };
41968     } catch (...) {
41969       {
41970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41971       };
41972     }
41973   }
41974
41975   jresult = (void *)result;
41976   return jresult;
41977 }
41978
41979
41980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
41981   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41982
41983   arg1 = (Dali::TapGesture *)jarg1;
41984   {
41985     try {
41986       delete arg1;
41987     } catch (std::out_of_range& e) {
41988       {
41989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41990       };
41991     } catch (std::exception& e) {
41992       {
41993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41994       };
41995     } catch (Dali::DaliException e) {
41996       {
41997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41998       };
41999     } catch (...) {
42000       {
42001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42002       };
42003     }
42004   }
42005
42006 }
42007
42008
42009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42010   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42011   unsigned int arg2 ;
42012
42013   arg1 = (Dali::TapGesture *)jarg1;
42014   arg2 = (unsigned int)jarg2;
42015   if (arg1) (arg1)->numberOfTaps = arg2;
42016 }
42017
42018
42019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42020   unsigned int jresult ;
42021   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42022   unsigned int result;
42023
42024   arg1 = (Dali::TapGesture *)jarg1;
42025   result = (unsigned int) ((arg1)->numberOfTaps);
42026   jresult = result;
42027   return jresult;
42028 }
42029
42030
42031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42032   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42033   unsigned int arg2 ;
42034
42035   arg1 = (Dali::TapGesture *)jarg1;
42036   arg2 = (unsigned int)jarg2;
42037   if (arg1) (arg1)->numberOfTouches = arg2;
42038 }
42039
42040
42041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42042   unsigned int jresult ;
42043   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42044   unsigned int result;
42045
42046   arg1 = (Dali::TapGesture *)jarg1;
42047   result = (unsigned int) ((arg1)->numberOfTouches);
42048   jresult = result;
42049   return jresult;
42050 }
42051
42052
42053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42054   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42055   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42056
42057   arg1 = (Dali::TapGesture *)jarg1;
42058   arg2 = (Dali::Vector2 *)jarg2;
42059   if (arg1) (arg1)->screenPoint = *arg2;
42060 }
42061
42062
42063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42064   void * jresult ;
42065   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42066   Dali::Vector2 *result = 0 ;
42067
42068   arg1 = (Dali::TapGesture *)jarg1;
42069   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42070   jresult = (void *)result;
42071   return jresult;
42072 }
42073
42074
42075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42076   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42077   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42078
42079   arg1 = (Dali::TapGesture *)jarg1;
42080   arg2 = (Dali::Vector2 *)jarg2;
42081   if (arg1) (arg1)->localPoint = *arg2;
42082 }
42083
42084
42085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42086   void * jresult ;
42087   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42088   Dali::Vector2 *result = 0 ;
42089
42090   arg1 = (Dali::TapGesture *)jarg1;
42091   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42092   jresult = (void *)result;
42093   return jresult;
42094 }
42095
42096
42097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42098   void * jresult ;
42099   Dali::AlphaFunction *result = 0 ;
42100
42101   {
42102     try {
42103       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42104     } catch (std::out_of_range& e) {
42105       {
42106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42107       };
42108     } catch (std::exception& e) {
42109       {
42110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42111       };
42112     } catch (Dali::DaliException e) {
42113       {
42114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42115       };
42116     } catch (...) {
42117       {
42118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42119       };
42120     }
42121   }
42122
42123   jresult = (void *)result;
42124   return jresult;
42125 }
42126
42127
42128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42129   void * jresult ;
42130   Dali::AlphaFunction::BuiltinFunction arg1 ;
42131   Dali::AlphaFunction *result = 0 ;
42132
42133   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42134   {
42135     try {
42136       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42137     } catch (std::out_of_range& e) {
42138       {
42139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42140       };
42141     } catch (std::exception& e) {
42142       {
42143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42144       };
42145     } catch (Dali::DaliException e) {
42146       {
42147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42148       };
42149     } catch (...) {
42150       {
42151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42152       };
42153     }
42154   }
42155
42156   jresult = (void *)result;
42157   return jresult;
42158 }
42159
42160
42161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42162   void * jresult ;
42163   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42164   Dali::AlphaFunction *result = 0 ;
42165
42166   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42167   {
42168     try {
42169       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42170     } catch (std::out_of_range& e) {
42171       {
42172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42173       };
42174     } catch (std::exception& e) {
42175       {
42176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42177       };
42178     } catch (Dali::DaliException e) {
42179       {
42180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42181       };
42182     } catch (...) {
42183       {
42184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42185       };
42186     }
42187   }
42188
42189   jresult = (void *)result;
42190   return jresult;
42191 }
42192
42193
42194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42195   void * jresult ;
42196   Dali::Vector2 *arg1 = 0 ;
42197   Dali::Vector2 *arg2 = 0 ;
42198   Dali::AlphaFunction *result = 0 ;
42199
42200   arg1 = (Dali::Vector2 *)jarg1;
42201   if (!arg1) {
42202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42203     return 0;
42204   }
42205   arg2 = (Dali::Vector2 *)jarg2;
42206   if (!arg2) {
42207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42208     return 0;
42209   }
42210   {
42211     try {
42212       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42213     } catch (std::out_of_range& e) {
42214       {
42215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42216       };
42217     } catch (std::exception& e) {
42218       {
42219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42220       };
42221     } catch (Dali::DaliException e) {
42222       {
42223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42224       };
42225     } catch (...) {
42226       {
42227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42228       };
42229     }
42230   }
42231
42232   jresult = (void *)result;
42233   return jresult;
42234 }
42235
42236
42237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42238   void * jresult ;
42239   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42240   Dali::Vector4 result;
42241
42242   arg1 = (Dali::AlphaFunction *)jarg1;
42243   {
42244     try {
42245       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42246     } catch (std::out_of_range& e) {
42247       {
42248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42249       };
42250     } catch (std::exception& e) {
42251       {
42252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42253       };
42254     } catch (Dali::DaliException e) {
42255       {
42256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42257       };
42258     } catch (...) {
42259       {
42260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42261       };
42262     }
42263   }
42264
42265   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42266   return jresult;
42267 }
42268
42269
42270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42271   void * jresult ;
42272   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42273   Dali::AlphaFunctionPrototype result;
42274
42275   arg1 = (Dali::AlphaFunction *)jarg1;
42276   {
42277     try {
42278       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42279     } catch (std::out_of_range& e) {
42280       {
42281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42282       };
42283     } catch (std::exception& e) {
42284       {
42285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42286       };
42287     } catch (Dali::DaliException e) {
42288       {
42289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42290       };
42291     } catch (...) {
42292       {
42293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42294       };
42295     }
42296   }
42297
42298   jresult = (void *)result;
42299   return jresult;
42300 }
42301
42302
42303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42304   int jresult ;
42305   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42306   Dali::AlphaFunction::BuiltinFunction result;
42307
42308   arg1 = (Dali::AlphaFunction *)jarg1;
42309   {
42310     try {
42311       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42312     } catch (std::out_of_range& e) {
42313       {
42314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42315       };
42316     } catch (std::exception& e) {
42317       {
42318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42319       };
42320     } catch (Dali::DaliException e) {
42321       {
42322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42323       };
42324     } catch (...) {
42325       {
42326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42327       };
42328     }
42329   }
42330
42331   jresult = (int)result;
42332   return jresult;
42333 }
42334
42335
42336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42337   int jresult ;
42338   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42339   Dali::AlphaFunction::Mode result;
42340
42341   arg1 = (Dali::AlphaFunction *)jarg1;
42342   {
42343     try {
42344       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42345     } catch (std::out_of_range& e) {
42346       {
42347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42348       };
42349     } catch (std::exception& e) {
42350       {
42351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42352       };
42353     } catch (Dali::DaliException e) {
42354       {
42355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42356       };
42357     } catch (...) {
42358       {
42359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42360       };
42361     }
42362   }
42363
42364   jresult = (int)result;
42365   return jresult;
42366 }
42367
42368
42369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42370   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42371
42372   arg1 = (Dali::AlphaFunction *)jarg1;
42373   {
42374     try {
42375       delete arg1;
42376     } catch (std::out_of_range& e) {
42377       {
42378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42379       };
42380     } catch (std::exception& e) {
42381       {
42382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42383       };
42384     } catch (Dali::DaliException e) {
42385       {
42386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42387       };
42388     } catch (...) {
42389       {
42390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42391       };
42392     }
42393   }
42394
42395 }
42396
42397
42398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42399   void * jresult ;
42400   Dali::KeyFrames result;
42401
42402   {
42403     try {
42404       result = Dali::KeyFrames::New();
42405     } catch (std::out_of_range& e) {
42406       {
42407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42408       };
42409     } catch (std::exception& e) {
42410       {
42411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42412       };
42413     } catch (Dali::DaliException e) {
42414       {
42415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42416       };
42417     } catch (...) {
42418       {
42419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42420       };
42421     }
42422   }
42423
42424   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42425   return jresult;
42426 }
42427
42428
42429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42430   void * jresult ;
42431   Dali::BaseHandle arg1 ;
42432   Dali::BaseHandle *argp1 ;
42433   Dali::KeyFrames result;
42434
42435   argp1 = (Dali::BaseHandle *)jarg1;
42436   if (!argp1) {
42437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42438     return 0;
42439   }
42440   arg1 = *argp1;
42441   {
42442     try {
42443       result = Dali::KeyFrames::DownCast(arg1);
42444     } catch (std::out_of_range& e) {
42445       {
42446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42447       };
42448     } catch (std::exception& e) {
42449       {
42450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42451       };
42452     } catch (Dali::DaliException e) {
42453       {
42454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42455       };
42456     } catch (...) {
42457       {
42458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42459       };
42460     }
42461   }
42462
42463   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42464   return jresult;
42465 }
42466
42467
42468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42469   void * jresult ;
42470   Dali::KeyFrames *result = 0 ;
42471
42472   {
42473     try {
42474       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42475     } catch (std::out_of_range& e) {
42476       {
42477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42478       };
42479     } catch (std::exception& e) {
42480       {
42481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42482       };
42483     } catch (Dali::DaliException e) {
42484       {
42485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42486       };
42487     } catch (...) {
42488       {
42489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42490       };
42491     }
42492   }
42493
42494   jresult = (void *)result;
42495   return jresult;
42496 }
42497
42498
42499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42500   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42501
42502   arg1 = (Dali::KeyFrames *)jarg1;
42503   {
42504     try {
42505       delete arg1;
42506     } catch (std::out_of_range& e) {
42507       {
42508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42509       };
42510     } catch (std::exception& e) {
42511       {
42512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42513       };
42514     } catch (Dali::DaliException e) {
42515       {
42516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42517       };
42518     } catch (...) {
42519       {
42520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42521       };
42522     }
42523   }
42524
42525 }
42526
42527
42528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42529   void * jresult ;
42530   Dali::KeyFrames *arg1 = 0 ;
42531   Dali::KeyFrames *result = 0 ;
42532
42533   arg1 = (Dali::KeyFrames *)jarg1;
42534   if (!arg1) {
42535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42536     return 0;
42537   }
42538   {
42539     try {
42540       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
42541     } catch (std::out_of_range& e) {
42542       {
42543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42544       };
42545     } catch (std::exception& e) {
42546       {
42547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42548       };
42549     } catch (Dali::DaliException e) {
42550       {
42551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42552       };
42553     } catch (...) {
42554       {
42555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42556       };
42557     }
42558   }
42559
42560   jresult = (void *)result;
42561   return jresult;
42562 }
42563
42564
42565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
42566   void * jresult ;
42567   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42568   Dali::KeyFrames *arg2 = 0 ;
42569   Dali::KeyFrames *result = 0 ;
42570
42571   arg1 = (Dali::KeyFrames *)jarg1;
42572   arg2 = (Dali::KeyFrames *)jarg2;
42573   if (!arg2) {
42574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42575     return 0;
42576   }
42577   {
42578     try {
42579       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
42580     } catch (std::out_of_range& e) {
42581       {
42582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42583       };
42584     } catch (std::exception& e) {
42585       {
42586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42587       };
42588     } catch (Dali::DaliException e) {
42589       {
42590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42591       };
42592     } catch (...) {
42593       {
42594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42595       };
42596     }
42597   }
42598
42599   jresult = (void *)result;
42600   return jresult;
42601 }
42602
42603
42604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
42605   int jresult ;
42606   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42607   Dali::Property::Type result;
42608
42609   arg1 = (Dali::KeyFrames *)jarg1;
42610   {
42611     try {
42612       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
42613     } catch (std::out_of_range& e) {
42614       {
42615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42616       };
42617     } catch (std::exception& e) {
42618       {
42619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42620       };
42621     } catch (Dali::DaliException e) {
42622       {
42623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42624       };
42625     } catch (...) {
42626       {
42627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42628       };
42629     }
42630   }
42631
42632   jresult = (int)result;
42633   return jresult;
42634 }
42635
42636
42637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
42638   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42639   float arg2 ;
42640   Dali::Property::Value arg3 ;
42641   Dali::Property::Value *argp3 ;
42642
42643   arg1 = (Dali::KeyFrames *)jarg1;
42644   arg2 = (float)jarg2;
42645   argp3 = (Dali::Property::Value *)jarg3;
42646   if (!argp3) {
42647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42648     return ;
42649   }
42650   arg3 = *argp3;
42651   {
42652     try {
42653       (arg1)->Add(arg2,arg3);
42654     } catch (std::out_of_range& e) {
42655       {
42656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42657       };
42658     } catch (std::exception& e) {
42659       {
42660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42661       };
42662     } catch (Dali::DaliException e) {
42663       {
42664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42665       };
42666     } catch (...) {
42667       {
42668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42669       };
42670     }
42671   }
42672
42673 }
42674
42675
42676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
42677   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42678   float arg2 ;
42679   Dali::Property::Value arg3 ;
42680   Dali::AlphaFunction arg4 ;
42681   Dali::Property::Value *argp3 ;
42682   Dali::AlphaFunction *argp4 ;
42683
42684   arg1 = (Dali::KeyFrames *)jarg1;
42685   arg2 = (float)jarg2;
42686   argp3 = (Dali::Property::Value *)jarg3;
42687   if (!argp3) {
42688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42689     return ;
42690   }
42691   arg3 = *argp3;
42692   argp4 = (Dali::AlphaFunction *)jarg4;
42693   if (!argp4) {
42694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
42695     return ;
42696   }
42697   arg4 = *argp4;
42698   {
42699     try {
42700       (arg1)->Add(arg2,arg3,arg4);
42701     } catch (std::out_of_range& e) {
42702       {
42703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42704       };
42705     } catch (std::exception& e) {
42706       {
42707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42708       };
42709     } catch (Dali::DaliException e) {
42710       {
42711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42712       };
42713     } catch (...) {
42714       {
42715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42716       };
42717     }
42718   }
42719
42720 }
42721
42722
42723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
42724   int jresult ;
42725   int result;
42726
42727   result = (int)Dali::Path::Property::POINTS;
42728   jresult = (int)result;
42729   return jresult;
42730 }
42731
42732
42733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
42734   int jresult ;
42735   int result;
42736
42737   result = (int)Dali::Path::Property::CONTROL_POINTS;
42738   jresult = (int)result;
42739   return jresult;
42740 }
42741
42742
42743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
42744   void * jresult ;
42745   Dali::Path::Property *result = 0 ;
42746
42747   {
42748     try {
42749       result = (Dali::Path::Property *)new Dali::Path::Property();
42750     } catch (std::out_of_range& e) {
42751       {
42752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42753       };
42754     } catch (std::exception& e) {
42755       {
42756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42757       };
42758     } catch (Dali::DaliException e) {
42759       {
42760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42761       };
42762     } catch (...) {
42763       {
42764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42765       };
42766     }
42767   }
42768
42769   jresult = (void *)result;
42770   return jresult;
42771 }
42772
42773
42774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
42775   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
42776
42777   arg1 = (Dali::Path::Property *)jarg1;
42778   {
42779     try {
42780       delete arg1;
42781     } catch (std::out_of_range& e) {
42782       {
42783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42784       };
42785     } catch (std::exception& e) {
42786       {
42787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42788       };
42789     } catch (Dali::DaliException e) {
42790       {
42791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42792       };
42793     } catch (...) {
42794       {
42795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42796       };
42797     }
42798   }
42799
42800 }
42801
42802
42803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
42804   void * jresult ;
42805   Dali::Path result;
42806
42807   {
42808     try {
42809       result = Dali::Path::New();
42810     } catch (std::out_of_range& e) {
42811       {
42812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42813       };
42814     } catch (std::exception& e) {
42815       {
42816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42817       };
42818     } catch (Dali::DaliException e) {
42819       {
42820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42821       };
42822     } catch (...) {
42823       {
42824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42825       };
42826     }
42827   }
42828
42829   jresult = new Dali::Path((const Dali::Path &)result);
42830   return jresult;
42831 }
42832
42833
42834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
42835   void * jresult ;
42836   Dali::BaseHandle arg1 ;
42837   Dali::BaseHandle *argp1 ;
42838   Dali::Path result;
42839
42840   argp1 = (Dali::BaseHandle *)jarg1;
42841   if (!argp1) {
42842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42843     return 0;
42844   }
42845   arg1 = *argp1;
42846   {
42847     try {
42848       result = Dali::Path::DownCast(arg1);
42849     } catch (std::out_of_range& e) {
42850       {
42851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42852       };
42853     } catch (std::exception& e) {
42854       {
42855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42856       };
42857     } catch (Dali::DaliException e) {
42858       {
42859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42860       };
42861     } catch (...) {
42862       {
42863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42864       };
42865     }
42866   }
42867
42868   jresult = new Dali::Path((const Dali::Path &)result);
42869   return jresult;
42870 }
42871
42872
42873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
42874   void * jresult ;
42875   Dali::Path *result = 0 ;
42876
42877   {
42878     try {
42879       result = (Dali::Path *)new Dali::Path();
42880     } catch (std::out_of_range& e) {
42881       {
42882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42883       };
42884     } catch (std::exception& e) {
42885       {
42886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42887       };
42888     } catch (Dali::DaliException e) {
42889       {
42890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42891       };
42892     } catch (...) {
42893       {
42894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42895       };
42896     }
42897   }
42898
42899   jresult = (void *)result;
42900   return jresult;
42901 }
42902
42903
42904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
42905   Dali::Path *arg1 = (Dali::Path *) 0 ;
42906
42907   arg1 = (Dali::Path *)jarg1;
42908   {
42909     try {
42910       delete arg1;
42911     } catch (std::out_of_range& e) {
42912       {
42913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42914       };
42915     } catch (std::exception& e) {
42916       {
42917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42918       };
42919     } catch (Dali::DaliException e) {
42920       {
42921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42922       };
42923     } catch (...) {
42924       {
42925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42926       };
42927     }
42928   }
42929
42930 }
42931
42932
42933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
42934   void * jresult ;
42935   Dali::Path *arg1 = 0 ;
42936   Dali::Path *result = 0 ;
42937
42938   arg1 = (Dali::Path *)jarg1;
42939   if (!arg1) {
42940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
42941     return 0;
42942   }
42943   {
42944     try {
42945       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
42946     } catch (std::out_of_range& e) {
42947       {
42948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42949       };
42950     } catch (std::exception& e) {
42951       {
42952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42953       };
42954     } catch (Dali::DaliException e) {
42955       {
42956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42957       };
42958     } catch (...) {
42959       {
42960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42961       };
42962     }
42963   }
42964
42965   jresult = (void *)result;
42966   return jresult;
42967 }
42968
42969
42970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
42971   void * jresult ;
42972   Dali::Path *arg1 = (Dali::Path *) 0 ;
42973   Dali::Path *arg2 = 0 ;
42974   Dali::Path *result = 0 ;
42975
42976   arg1 = (Dali::Path *)jarg1;
42977   arg2 = (Dali::Path *)jarg2;
42978   if (!arg2) {
42979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
42980     return 0;
42981   }
42982   {
42983     try {
42984       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
42985     } catch (std::out_of_range& e) {
42986       {
42987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42988       };
42989     } catch (std::exception& e) {
42990       {
42991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42992       };
42993     } catch (Dali::DaliException e) {
42994       {
42995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42996       };
42997     } catch (...) {
42998       {
42999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43000       };
43001     }
43002   }
43003
43004   jresult = (void *)result;
43005   return jresult;
43006 }
43007
43008
43009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43010   Dali::Path *arg1 = (Dali::Path *) 0 ;
43011   Dali::Vector3 *arg2 = 0 ;
43012
43013   arg1 = (Dali::Path *)jarg1;
43014   arg2 = (Dali::Vector3 *)jarg2;
43015   if (!arg2) {
43016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43017     return ;
43018   }
43019   {
43020     try {
43021       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43022     } catch (std::out_of_range& e) {
43023       {
43024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43025       };
43026     } catch (std::exception& e) {
43027       {
43028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43029       };
43030     } catch (Dali::DaliException e) {
43031       {
43032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43033       };
43034     } catch (...) {
43035       {
43036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43037       };
43038     }
43039   }
43040
43041 }
43042
43043
43044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43045   Dali::Path *arg1 = (Dali::Path *) 0 ;
43046   Dali::Vector3 *arg2 = 0 ;
43047
43048   arg1 = (Dali::Path *)jarg1;
43049   arg2 = (Dali::Vector3 *)jarg2;
43050   if (!arg2) {
43051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43052     return ;
43053   }
43054   {
43055     try {
43056       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43057     } catch (std::out_of_range& e) {
43058       {
43059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43060       };
43061     } catch (std::exception& e) {
43062       {
43063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43064       };
43065     } catch (Dali::DaliException e) {
43066       {
43067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43068       };
43069     } catch (...) {
43070       {
43071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43072       };
43073     }
43074   }
43075
43076 }
43077
43078
43079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43080   Dali::Path *arg1 = (Dali::Path *) 0 ;
43081   float arg2 ;
43082
43083   arg1 = (Dali::Path *)jarg1;
43084   arg2 = (float)jarg2;
43085   {
43086     try {
43087       (arg1)->GenerateControlPoints(arg2);
43088     } catch (std::out_of_range& e) {
43089       {
43090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43091       };
43092     } catch (std::exception& e) {
43093       {
43094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43095       };
43096     } catch (Dali::DaliException e) {
43097       {
43098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43099       };
43100     } catch (...) {
43101       {
43102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43103       };
43104     }
43105   }
43106
43107 }
43108
43109
43110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43111   Dali::Path *arg1 = (Dali::Path *) 0 ;
43112   float arg2 ;
43113   Dali::Vector3 *arg3 = 0 ;
43114   Dali::Vector3 *arg4 = 0 ;
43115
43116   arg1 = (Dali::Path *)jarg1;
43117   arg2 = (float)jarg2;
43118   arg3 = (Dali::Vector3 *)jarg3;
43119   if (!arg3) {
43120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43121     return ;
43122   }
43123   arg4 = (Dali::Vector3 *)jarg4;
43124   if (!arg4) {
43125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43126     return ;
43127   }
43128   {
43129     try {
43130       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43131     } catch (std::out_of_range& e) {
43132       {
43133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43134       };
43135     } catch (std::exception& e) {
43136       {
43137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43138       };
43139     } catch (Dali::DaliException e) {
43140       {
43141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43142       };
43143     } catch (...) {
43144       {
43145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43146       };
43147     }
43148   }
43149
43150 }
43151
43152
43153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43154   void * jresult ;
43155   Dali::Path *arg1 = (Dali::Path *) 0 ;
43156   size_t arg2 ;
43157   Dali::Vector3 *result = 0 ;
43158
43159   arg1 = (Dali::Path *)jarg1;
43160   arg2 = (size_t)jarg2;
43161   {
43162     try {
43163       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43164     } catch (std::out_of_range& e) {
43165       {
43166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43167       };
43168     } catch (std::exception& e) {
43169       {
43170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43171       };
43172     } catch (Dali::DaliException e) {
43173       {
43174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43175       };
43176     } catch (...) {
43177       {
43178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43179       };
43180     }
43181   }
43182
43183   jresult = (void *)result;
43184   return jresult;
43185 }
43186
43187
43188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43189   void * jresult ;
43190   Dali::Path *arg1 = (Dali::Path *) 0 ;
43191   size_t arg2 ;
43192   Dali::Vector3 *result = 0 ;
43193
43194   arg1 = (Dali::Path *)jarg1;
43195   arg2 = (size_t)jarg2;
43196   {
43197     try {
43198       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43199     } catch (std::out_of_range& e) {
43200       {
43201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43202       };
43203     } catch (std::exception& e) {
43204       {
43205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43206       };
43207     } catch (Dali::DaliException e) {
43208       {
43209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43210       };
43211     } catch (...) {
43212       {
43213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43214       };
43215     }
43216   }
43217
43218   jresult = (void *)result;
43219   return jresult;
43220 }
43221
43222
43223 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43224   unsigned long jresult ;
43225   Dali::Path *arg1 = (Dali::Path *) 0 ;
43226   size_t result;
43227
43228   arg1 = (Dali::Path *)jarg1;
43229   {
43230     try {
43231       result = ((Dali::Path const *)arg1)->GetPointCount();
43232     } catch (std::out_of_range& e) {
43233       {
43234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43235       };
43236     } catch (std::exception& e) {
43237       {
43238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43239       };
43240     } catch (Dali::DaliException e) {
43241       {
43242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43243       };
43244     } catch (...) {
43245       {
43246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43247       };
43248     }
43249   }
43250
43251   jresult = (unsigned long)result;
43252   return jresult;
43253 }
43254
43255
43256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43257   void * jresult ;
43258   float arg1 ;
43259   Dali::TimePeriod *result = 0 ;
43260
43261   arg1 = (float)jarg1;
43262   {
43263     try {
43264       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43265     } catch (std::out_of_range& e) {
43266       {
43267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43268       };
43269     } catch (std::exception& e) {
43270       {
43271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43272       };
43273     } catch (Dali::DaliException e) {
43274       {
43275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43276       };
43277     } catch (...) {
43278       {
43279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43280       };
43281     }
43282   }
43283
43284   jresult = (void *)result;
43285   return jresult;
43286 }
43287
43288
43289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43290   void * jresult ;
43291   float arg1 ;
43292   float arg2 ;
43293   Dali::TimePeriod *result = 0 ;
43294
43295   arg1 = (float)jarg1;
43296   arg2 = (float)jarg2;
43297   {
43298     try {
43299       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43300     } catch (std::out_of_range& e) {
43301       {
43302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43303       };
43304     } catch (std::exception& e) {
43305       {
43306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43307       };
43308     } catch (Dali::DaliException e) {
43309       {
43310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43311       };
43312     } catch (...) {
43313       {
43314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43315       };
43316     }
43317   }
43318
43319   jresult = (void *)result;
43320   return jresult;
43321 }
43322
43323
43324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43325   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43326
43327   arg1 = (Dali::TimePeriod *)jarg1;
43328   {
43329     try {
43330       delete arg1;
43331     } catch (std::out_of_range& e) {
43332       {
43333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43334       };
43335     } catch (std::exception& e) {
43336       {
43337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43338       };
43339     } catch (Dali::DaliException e) {
43340       {
43341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43342       };
43343     } catch (...) {
43344       {
43345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43346       };
43347     }
43348   }
43349
43350 }
43351
43352
43353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43354   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43355   float arg2 ;
43356
43357   arg1 = (Dali::TimePeriod *)jarg1;
43358   arg2 = (float)jarg2;
43359   if (arg1) (arg1)->delaySeconds = arg2;
43360 }
43361
43362
43363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43364   float jresult ;
43365   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43366   float result;
43367
43368   arg1 = (Dali::TimePeriod *)jarg1;
43369   result = (float) ((arg1)->delaySeconds);
43370   jresult = result;
43371   return jresult;
43372 }
43373
43374
43375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43376   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43377   float arg2 ;
43378
43379   arg1 = (Dali::TimePeriod *)jarg1;
43380   arg2 = (float)jarg2;
43381   if (arg1) (arg1)->durationSeconds = arg2;
43382 }
43383
43384
43385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43386   float jresult ;
43387   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43388   float result;
43389
43390   arg1 = (Dali::TimePeriod *)jarg1;
43391   result = (float) ((arg1)->durationSeconds);
43392   jresult = result;
43393   return jresult;
43394 }
43395
43396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43397   int jresult ;
43398   int result;
43399
43400   result = (int)Dali::LinearConstrainer::Property::VALUE;
43401   jresult = (int)result;
43402   return jresult;
43403 }
43404
43405
43406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43407   int jresult ;
43408   int result;
43409
43410   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43411   jresult = (int)result;
43412   return jresult;
43413 }
43414
43415
43416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43417   void * jresult ;
43418   Dali::LinearConstrainer::Property *result = 0 ;
43419
43420   {
43421     try {
43422       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43423     } catch (std::out_of_range& e) {
43424       {
43425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43426       };
43427     } catch (std::exception& e) {
43428       {
43429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43430       };
43431     } catch (Dali::DaliException e) {
43432       {
43433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43434       };
43435     } catch (...) {
43436       {
43437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43438       };
43439     }
43440   }
43441
43442   jresult = (void *)result;
43443   return jresult;
43444 }
43445
43446
43447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43448   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43449
43450   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43451   {
43452     try {
43453       delete arg1;
43454     } catch (std::out_of_range& e) {
43455       {
43456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43457       };
43458     } catch (std::exception& e) {
43459       {
43460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43461       };
43462     } catch (Dali::DaliException e) {
43463       {
43464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43465       };
43466     } catch (...) {
43467       {
43468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43469       };
43470     }
43471   }
43472
43473 }
43474
43475
43476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43477   void * jresult ;
43478   Dali::LinearConstrainer result;
43479
43480   {
43481     try {
43482       result = Dali::LinearConstrainer::New();
43483     } catch (std::out_of_range& e) {
43484       {
43485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43486       };
43487     } catch (std::exception& e) {
43488       {
43489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43490       };
43491     } catch (Dali::DaliException e) {
43492       {
43493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43494       };
43495     } catch (...) {
43496       {
43497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43498       };
43499     }
43500   }
43501
43502   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43503   return jresult;
43504 }
43505
43506
43507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43508   void * jresult ;
43509   Dali::BaseHandle arg1 ;
43510   Dali::BaseHandle *argp1 ;
43511   Dali::LinearConstrainer result;
43512
43513   argp1 = (Dali::BaseHandle *)jarg1;
43514   if (!argp1) {
43515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43516     return 0;
43517   }
43518   arg1 = *argp1;
43519   {
43520     try {
43521       result = Dali::LinearConstrainer::DownCast(arg1);
43522     } catch (std::out_of_range& e) {
43523       {
43524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43525       };
43526     } catch (std::exception& e) {
43527       {
43528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43529       };
43530     } catch (Dali::DaliException e) {
43531       {
43532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43533       };
43534     } catch (...) {
43535       {
43536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43537       };
43538     }
43539   }
43540
43541   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43542   return jresult;
43543 }
43544
43545
43546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
43547   void * jresult ;
43548   Dali::LinearConstrainer *result = 0 ;
43549
43550   {
43551     try {
43552       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
43553     } catch (std::out_of_range& e) {
43554       {
43555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43556       };
43557     } catch (std::exception& e) {
43558       {
43559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43560       };
43561     } catch (Dali::DaliException e) {
43562       {
43563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43564       };
43565     } catch (...) {
43566       {
43567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43568       };
43569     }
43570   }
43571
43572   jresult = (void *)result;
43573   return jresult;
43574 }
43575
43576
43577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
43578   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43579
43580   arg1 = (Dali::LinearConstrainer *)jarg1;
43581   {
43582     try {
43583       delete arg1;
43584     } catch (std::out_of_range& e) {
43585       {
43586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43587       };
43588     } catch (std::exception& e) {
43589       {
43590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43591       };
43592     } catch (Dali::DaliException e) {
43593       {
43594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43595       };
43596     } catch (...) {
43597       {
43598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43599       };
43600     }
43601   }
43602
43603 }
43604
43605
43606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
43607   void * jresult ;
43608   Dali::LinearConstrainer *arg1 = 0 ;
43609   Dali::LinearConstrainer *result = 0 ;
43610
43611   arg1 = (Dali::LinearConstrainer *)jarg1;
43612   if (!arg1) {
43613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43614     return 0;
43615   }
43616   {
43617     try {
43618       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
43619     } catch (std::out_of_range& e) {
43620       {
43621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43622       };
43623     } catch (std::exception& e) {
43624       {
43625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43626       };
43627     } catch (Dali::DaliException e) {
43628       {
43629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43630       };
43631     } catch (...) {
43632       {
43633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43634       };
43635     }
43636   }
43637
43638   jresult = (void *)result;
43639   return jresult;
43640 }
43641
43642
43643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
43644   void * jresult ;
43645   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43646   Dali::LinearConstrainer *arg2 = 0 ;
43647   Dali::LinearConstrainer *result = 0 ;
43648
43649   arg1 = (Dali::LinearConstrainer *)jarg1;
43650   arg2 = (Dali::LinearConstrainer *)jarg2;
43651   if (!arg2) {
43652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43653     return 0;
43654   }
43655   {
43656     try {
43657       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
43658     } catch (std::out_of_range& e) {
43659       {
43660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43661       };
43662     } catch (std::exception& e) {
43663       {
43664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43665       };
43666     } catch (Dali::DaliException e) {
43667       {
43668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43669       };
43670     } catch (...) {
43671       {
43672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43673       };
43674     }
43675   }
43676
43677   jresult = (void *)result;
43678   return jresult;
43679 }
43680
43681
43682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
43683   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43684   SwigValueWrapper< Dali::Property > arg2 ;
43685   SwigValueWrapper< Dali::Property > arg3 ;
43686   Dali::Vector2 *arg4 = 0 ;
43687   Dali::Vector2 *arg5 = 0 ;
43688   Dali::Property *argp2 ;
43689   Dali::Property *argp3 ;
43690
43691   arg1 = (Dali::LinearConstrainer *)jarg1;
43692   argp2 = (Dali::Property *)jarg2;
43693   if (!argp2) {
43694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43695     return ;
43696   }
43697   arg2 = *argp2;
43698   argp3 = (Dali::Property *)jarg3;
43699   if (!argp3) {
43700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43701     return ;
43702   }
43703   arg3 = *argp3;
43704   arg4 = (Dali::Vector2 *)jarg4;
43705   if (!arg4) {
43706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43707     return ;
43708   }
43709   arg5 = (Dali::Vector2 *)jarg5;
43710   if (!arg5) {
43711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43712     return ;
43713   }
43714   {
43715     try {
43716       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
43717     } catch (std::out_of_range& e) {
43718       {
43719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43720       };
43721     } catch (std::exception& e) {
43722       {
43723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43724       };
43725     } catch (Dali::DaliException e) {
43726       {
43727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43728       };
43729     } catch (...) {
43730       {
43731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43732       };
43733     }
43734   }
43735
43736 }
43737
43738
43739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
43740   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43741   SwigValueWrapper< Dali::Property > arg2 ;
43742   SwigValueWrapper< Dali::Property > arg3 ;
43743   Dali::Vector2 *arg4 = 0 ;
43744   Dali::Property *argp2 ;
43745   Dali::Property *argp3 ;
43746
43747   arg1 = (Dali::LinearConstrainer *)jarg1;
43748   argp2 = (Dali::Property *)jarg2;
43749   if (!argp2) {
43750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43751     return ;
43752   }
43753   arg2 = *argp2;
43754   argp3 = (Dali::Property *)jarg3;
43755   if (!argp3) {
43756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43757     return ;
43758   }
43759   arg3 = *argp3;
43760   arg4 = (Dali::Vector2 *)jarg4;
43761   if (!arg4) {
43762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43763     return ;
43764   }
43765   {
43766     try {
43767       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
43768     } catch (std::out_of_range& e) {
43769       {
43770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43771       };
43772     } catch (std::exception& e) {
43773       {
43774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43775       };
43776     } catch (Dali::DaliException e) {
43777       {
43778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43779       };
43780     } catch (...) {
43781       {
43782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43783       };
43784     }
43785   }
43786
43787 }
43788
43789
43790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
43791   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43792   Dali::Handle *arg2 = 0 ;
43793
43794   arg1 = (Dali::LinearConstrainer *)jarg1;
43795   arg2 = (Dali::Handle *)jarg2;
43796   if (!arg2) {
43797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
43798     return ;
43799   }
43800   {
43801     try {
43802       (arg1)->Remove(*arg2);
43803     } catch (std::out_of_range& e) {
43804       {
43805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43806       };
43807     } catch (std::exception& e) {
43808       {
43809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43810       };
43811     } catch (Dali::DaliException e) {
43812       {
43813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43814       };
43815     } catch (...) {
43816       {
43817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43818       };
43819     }
43820   }
43821
43822 }
43823
43824
43825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
43826   int jresult ;
43827   int result;
43828
43829   result = (int)Dali::PathConstrainer::Property::FORWARD;
43830   jresult = (int)result;
43831   return jresult;
43832 }
43833
43834
43835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
43836   int jresult ;
43837   int result;
43838
43839   result = (int)Dali::PathConstrainer::Property::POINTS;
43840   jresult = (int)result;
43841   return jresult;
43842 }
43843
43844
43845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
43846   int jresult ;
43847   int result;
43848
43849   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
43850   jresult = (int)result;
43851   return jresult;
43852 }
43853
43854
43855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
43856   void * jresult ;
43857   Dali::PathConstrainer::Property *result = 0 ;
43858
43859   {
43860     try {
43861       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
43862     } catch (std::out_of_range& e) {
43863       {
43864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43865       };
43866     } catch (std::exception& e) {
43867       {
43868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43869       };
43870     } catch (Dali::DaliException e) {
43871       {
43872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43873       };
43874     } catch (...) {
43875       {
43876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43877       };
43878     }
43879   }
43880
43881   jresult = (void *)result;
43882   return jresult;
43883 }
43884
43885
43886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
43887   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
43888
43889   arg1 = (Dali::PathConstrainer::Property *)jarg1;
43890   {
43891     try {
43892       delete arg1;
43893     } catch (std::out_of_range& e) {
43894       {
43895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43896       };
43897     } catch (std::exception& e) {
43898       {
43899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43900       };
43901     } catch (Dali::DaliException e) {
43902       {
43903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43904       };
43905     } catch (...) {
43906       {
43907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43908       };
43909     }
43910   }
43911
43912 }
43913
43914
43915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
43916   void * jresult ;
43917   Dali::PathConstrainer result;
43918
43919   {
43920     try {
43921       result = Dali::PathConstrainer::New();
43922     } catch (std::out_of_range& e) {
43923       {
43924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43925       };
43926     } catch (std::exception& e) {
43927       {
43928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43929       };
43930     } catch (Dali::DaliException e) {
43931       {
43932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43933       };
43934     } catch (...) {
43935       {
43936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43937       };
43938     }
43939   }
43940
43941   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
43942   return jresult;
43943 }
43944
43945
43946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
43947   void * jresult ;
43948   Dali::BaseHandle arg1 ;
43949   Dali::BaseHandle *argp1 ;
43950   Dali::PathConstrainer result;
43951
43952   argp1 = (Dali::BaseHandle *)jarg1;
43953   if (!argp1) {
43954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43955     return 0;
43956   }
43957   arg1 = *argp1;
43958   {
43959     try {
43960       result = Dali::PathConstrainer::DownCast(arg1);
43961     } catch (std::out_of_range& e) {
43962       {
43963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43964       };
43965     } catch (std::exception& e) {
43966       {
43967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43968       };
43969     } catch (Dali::DaliException e) {
43970       {
43971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43972       };
43973     } catch (...) {
43974       {
43975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43976       };
43977     }
43978   }
43979
43980   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
43981   return jresult;
43982 }
43983
43984
43985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
43986   void * jresult ;
43987   Dali::PathConstrainer *result = 0 ;
43988
43989   {
43990     try {
43991       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
43992     } catch (std::out_of_range& e) {
43993       {
43994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43995       };
43996     } catch (std::exception& e) {
43997       {
43998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43999       };
44000     } catch (Dali::DaliException e) {
44001       {
44002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44003       };
44004     } catch (...) {
44005       {
44006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44007       };
44008     }
44009   }
44010
44011   jresult = (void *)result;
44012   return jresult;
44013 }
44014
44015
44016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44017   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44018
44019   arg1 = (Dali::PathConstrainer *)jarg1;
44020   {
44021     try {
44022       delete arg1;
44023     } catch (std::out_of_range& e) {
44024       {
44025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44026       };
44027     } catch (std::exception& e) {
44028       {
44029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44030       };
44031     } catch (Dali::DaliException e) {
44032       {
44033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44034       };
44035     } catch (...) {
44036       {
44037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44038       };
44039     }
44040   }
44041
44042 }
44043
44044
44045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44046   void * jresult ;
44047   Dali::PathConstrainer *arg1 = 0 ;
44048   Dali::PathConstrainer *result = 0 ;
44049
44050   arg1 = (Dali::PathConstrainer *)jarg1;
44051   if (!arg1) {
44052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44053     return 0;
44054   }
44055   {
44056     try {
44057       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44058     } catch (std::out_of_range& e) {
44059       {
44060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44061       };
44062     } catch (std::exception& e) {
44063       {
44064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44065       };
44066     } catch (Dali::DaliException e) {
44067       {
44068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44069       };
44070     } catch (...) {
44071       {
44072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44073       };
44074     }
44075   }
44076
44077   jresult = (void *)result;
44078   return jresult;
44079 }
44080
44081
44082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44083   void * jresult ;
44084   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44085   Dali::PathConstrainer *arg2 = 0 ;
44086   Dali::PathConstrainer *result = 0 ;
44087
44088   arg1 = (Dali::PathConstrainer *)jarg1;
44089   arg2 = (Dali::PathConstrainer *)jarg2;
44090   if (!arg2) {
44091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44092     return 0;
44093   }
44094   {
44095     try {
44096       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44097     } catch (std::out_of_range& e) {
44098       {
44099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44100       };
44101     } catch (std::exception& e) {
44102       {
44103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44104       };
44105     } catch (Dali::DaliException e) {
44106       {
44107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44108       };
44109     } catch (...) {
44110       {
44111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44112       };
44113     }
44114   }
44115
44116   jresult = (void *)result;
44117   return jresult;
44118 }
44119
44120
44121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44122   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44123   SwigValueWrapper< Dali::Property > arg2 ;
44124   SwigValueWrapper< Dali::Property > arg3 ;
44125   Dali::Vector2 *arg4 = 0 ;
44126   Dali::Vector2 *arg5 = 0 ;
44127   Dali::Property *argp2 ;
44128   Dali::Property *argp3 ;
44129
44130   arg1 = (Dali::PathConstrainer *)jarg1;
44131   argp2 = (Dali::Property *)jarg2;
44132   if (!argp2) {
44133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44134     return ;
44135   }
44136   arg2 = *argp2;
44137   argp3 = (Dali::Property *)jarg3;
44138   if (!argp3) {
44139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44140     return ;
44141   }
44142   arg3 = *argp3;
44143   arg4 = (Dali::Vector2 *)jarg4;
44144   if (!arg4) {
44145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44146     return ;
44147   }
44148   arg5 = (Dali::Vector2 *)jarg5;
44149   if (!arg5) {
44150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44151     return ;
44152   }
44153   {
44154     try {
44155       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44156     } catch (std::out_of_range& e) {
44157       {
44158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44159       };
44160     } catch (std::exception& e) {
44161       {
44162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44163       };
44164     } catch (Dali::DaliException e) {
44165       {
44166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44167       };
44168     } catch (...) {
44169       {
44170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44171       };
44172     }
44173   }
44174
44175 }
44176
44177
44178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44179   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44180   SwigValueWrapper< Dali::Property > arg2 ;
44181   SwigValueWrapper< Dali::Property > arg3 ;
44182   Dali::Vector2 *arg4 = 0 ;
44183   Dali::Property *argp2 ;
44184   Dali::Property *argp3 ;
44185
44186   arg1 = (Dali::PathConstrainer *)jarg1;
44187   argp2 = (Dali::Property *)jarg2;
44188   if (!argp2) {
44189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44190     return ;
44191   }
44192   arg2 = *argp2;
44193   argp3 = (Dali::Property *)jarg3;
44194   if (!argp3) {
44195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44196     return ;
44197   }
44198   arg3 = *argp3;
44199   arg4 = (Dali::Vector2 *)jarg4;
44200   if (!arg4) {
44201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44202     return ;
44203   }
44204   {
44205     try {
44206       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44207     } catch (std::out_of_range& e) {
44208       {
44209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44210       };
44211     } catch (std::exception& e) {
44212       {
44213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44214       };
44215     } catch (Dali::DaliException e) {
44216       {
44217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44218       };
44219     } catch (...) {
44220       {
44221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44222       };
44223     }
44224   }
44225
44226 }
44227
44228
44229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44230   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44231   Dali::Handle *arg2 = 0 ;
44232
44233   arg1 = (Dali::PathConstrainer *)jarg1;
44234   arg2 = (Dali::Handle *)jarg2;
44235   if (!arg2) {
44236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44237     return ;
44238   }
44239   {
44240     try {
44241       (arg1)->Remove(*arg2);
44242     } catch (std::out_of_range& e) {
44243       {
44244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44245       };
44246     } catch (std::exception& e) {
44247       {
44248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44249       };
44250     } catch (Dali::DaliException e) {
44251       {
44252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44253       };
44254     } catch (...) {
44255       {
44256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44257       };
44258     }
44259   }
44260
44261 }
44262
44263
44264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44265   int jresult ;
44266   Dali::FittingMode::Type result;
44267
44268   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44269   jresult = (int)result;
44270   return jresult;
44271 }
44272
44273
44274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44275   int jresult ;
44276   Dali::SamplingMode::Type result;
44277
44278   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44279   jresult = (int)result;
44280   return jresult;
44281 }
44282
44283
44284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
44285   unsigned int jresult ;
44286   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44287   bool result;
44288
44289   arg1 = (Dali::NativeImageInterface *)jarg1;
44290   {
44291     try {
44292       result = (bool)(arg1)->CreateResource();
44293     } catch (std::out_of_range& e) {
44294       {
44295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44296       };
44297     } catch (std::exception& e) {
44298       {
44299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44300       };
44301     } catch (Dali::DaliException e) {
44302       {
44303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44304       };
44305     } catch (...) {
44306       {
44307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44308       };
44309     }
44310   }
44311
44312   jresult = result;
44313   return jresult;
44314 }
44315
44316
44317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
44318   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44319
44320   arg1 = (Dali::NativeImageInterface *)jarg1;
44321   {
44322     try {
44323       (arg1)->DestroyResource();
44324     } catch (std::out_of_range& e) {
44325       {
44326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44327       };
44328     } catch (std::exception& e) {
44329       {
44330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44331       };
44332     } catch (Dali::DaliException e) {
44333       {
44334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44335       };
44336     } catch (...) {
44337       {
44338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44339       };
44340     }
44341   }
44342
44343 }
44344
44345
44346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44347   unsigned int jresult ;
44348   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44349   unsigned int result;
44350
44351   arg1 = (Dali::NativeImageInterface *)jarg1;
44352   {
44353     try {
44354       result = (unsigned int)(arg1)->TargetTexture();
44355     } catch (std::out_of_range& e) {
44356       {
44357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44358       };
44359     } catch (std::exception& e) {
44360       {
44361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44362       };
44363     } catch (Dali::DaliException e) {
44364       {
44365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44366       };
44367     } catch (...) {
44368       {
44369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44370       };
44371     }
44372   }
44373
44374   jresult = result;
44375   return jresult;
44376 }
44377
44378
44379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44380   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44381
44382   arg1 = (Dali::NativeImageInterface *)jarg1;
44383   {
44384     try {
44385       (arg1)->PrepareTexture();
44386     } catch (std::out_of_range& e) {
44387       {
44388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44389       };
44390     } catch (std::exception& e) {
44391       {
44392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44393       };
44394     } catch (Dali::DaliException e) {
44395       {
44396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44397       };
44398     } catch (...) {
44399       {
44400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44401       };
44402     }
44403   }
44404
44405 }
44406
44407
44408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44409   unsigned int jresult ;
44410   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44411   unsigned int result;
44412
44413   arg1 = (Dali::NativeImageInterface *)jarg1;
44414   {
44415     try {
44416       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44417     } catch (std::out_of_range& e) {
44418       {
44419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44420       };
44421     } catch (std::exception& e) {
44422       {
44423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44424       };
44425     } catch (Dali::DaliException e) {
44426       {
44427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44428       };
44429     } catch (...) {
44430       {
44431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44432       };
44433     }
44434   }
44435
44436   jresult = result;
44437   return jresult;
44438 }
44439
44440
44441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44442   unsigned int jresult ;
44443   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44444   unsigned int result;
44445
44446   arg1 = (Dali::NativeImageInterface *)jarg1;
44447   {
44448     try {
44449       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44450     } catch (std::out_of_range& e) {
44451       {
44452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44453       };
44454     } catch (std::exception& e) {
44455       {
44456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44457       };
44458     } catch (Dali::DaliException e) {
44459       {
44460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44461       };
44462     } catch (...) {
44463       {
44464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44465       };
44466     }
44467   }
44468
44469   jresult = result;
44470   return jresult;
44471 }
44472
44473
44474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44475   unsigned int jresult ;
44476   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44477   bool result;
44478
44479   arg1 = (Dali::NativeImageInterface *)jarg1;
44480   {
44481     try {
44482       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44483     } catch (std::out_of_range& e) {
44484       {
44485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44486       };
44487     } catch (std::exception& e) {
44488       {
44489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44490       };
44491     } catch (Dali::DaliException e) {
44492       {
44493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44494       };
44495     } catch (...) {
44496       {
44497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44498       };
44499     }
44500   }
44501
44502   jresult = result;
44503   return jresult;
44504 }
44505
44506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44507   int jresult ;
44508   int result;
44509
44510   result = (int)Dali::CameraActor::Property::TYPE;
44511   jresult = (int)result;
44512   return jresult;
44513 }
44514
44515
44516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44517   int jresult ;
44518   int result;
44519
44520   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44521   jresult = (int)result;
44522   return jresult;
44523 }
44524
44525
44526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44527   int jresult ;
44528   int result;
44529
44530   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44531   jresult = (int)result;
44532   return jresult;
44533 }
44534
44535
44536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44537   int jresult ;
44538   int result;
44539
44540   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
44541   jresult = (int)result;
44542   return jresult;
44543 }
44544
44545
44546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
44547   int jresult ;
44548   int result;
44549
44550   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
44551   jresult = (int)result;
44552   return jresult;
44553 }
44554
44555
44556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
44557   int jresult ;
44558   int result;
44559
44560   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
44561   jresult = (int)result;
44562   return jresult;
44563 }
44564
44565
44566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
44567   int jresult ;
44568   int result;
44569
44570   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
44571   jresult = (int)result;
44572   return jresult;
44573 }
44574
44575
44576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
44577   int jresult ;
44578   int result;
44579
44580   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
44581   jresult = (int)result;
44582   return jresult;
44583 }
44584
44585
44586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
44587   int jresult ;
44588   int result;
44589
44590   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
44591   jresult = (int)result;
44592   return jresult;
44593 }
44594
44595
44596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
44597   int jresult ;
44598   int result;
44599
44600   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
44601   jresult = (int)result;
44602   return jresult;
44603 }
44604
44605
44606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
44607   int jresult ;
44608   int result;
44609
44610   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
44611   jresult = (int)result;
44612   return jresult;
44613 }
44614
44615
44616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
44617   int jresult ;
44618   int result;
44619
44620   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
44621   jresult = (int)result;
44622   return jresult;
44623 }
44624
44625
44626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
44627   int jresult ;
44628   int result;
44629
44630   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
44631   jresult = (int)result;
44632   return jresult;
44633 }
44634
44635
44636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
44637   int jresult ;
44638   int result;
44639
44640   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
44641   jresult = (int)result;
44642   return jresult;
44643 }
44644
44645
44646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
44647   void * jresult ;
44648   Dali::CameraActor::Property *result = 0 ;
44649
44650   {
44651     try {
44652       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
44653     } catch (std::out_of_range& e) {
44654       {
44655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44656       };
44657     } catch (std::exception& e) {
44658       {
44659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44660       };
44661     } catch (Dali::DaliException e) {
44662       {
44663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44664       };
44665     } catch (...) {
44666       {
44667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44668       };
44669     }
44670   }
44671
44672   jresult = (void *)result;
44673   return jresult;
44674 }
44675
44676
44677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
44678   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
44679
44680   arg1 = (Dali::CameraActor::Property *)jarg1;
44681   {
44682     try {
44683       delete arg1;
44684     } catch (std::out_of_range& e) {
44685       {
44686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44687       };
44688     } catch (std::exception& e) {
44689       {
44690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44691       };
44692     } catch (Dali::DaliException e) {
44693       {
44694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44695       };
44696     } catch (...) {
44697       {
44698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44699       };
44700     }
44701   }
44702
44703 }
44704
44705
44706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44707   void * jresult ;
44708   Dali::CameraActor *result = 0 ;
44709
44710   {
44711     try {
44712       result = (Dali::CameraActor *)new Dali::CameraActor();
44713     } catch (std::out_of_range& e) {
44714       {
44715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44716       };
44717     } catch (std::exception& e) {
44718       {
44719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44720       };
44721     } catch (Dali::DaliException e) {
44722       {
44723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44724       };
44725     } catch (...) {
44726       {
44727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44728       };
44729     }
44730   }
44731
44732   jresult = (void *)result;
44733   return jresult;
44734 }
44735
44736
44737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44738   void * jresult ;
44739   Dali::CameraActor result;
44740
44741   {
44742     try {
44743       result = Dali::CameraActor::New();
44744     } catch (std::out_of_range& e) {
44745       {
44746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44747       };
44748     } catch (std::exception& e) {
44749       {
44750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44751       };
44752     } catch (Dali::DaliException e) {
44753       {
44754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44755       };
44756     } catch (...) {
44757       {
44758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44759       };
44760     }
44761   }
44762
44763   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44764   return jresult;
44765 }
44766
44767
44768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
44769   void * jresult ;
44770   Dali::Size *arg1 = 0 ;
44771   Dali::CameraActor result;
44772
44773   arg1 = (Dali::Size *)jarg1;
44774   if (!arg1) {
44775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44776     return 0;
44777   }
44778   {
44779     try {
44780       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
44781     } catch (std::out_of_range& e) {
44782       {
44783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44784       };
44785     } catch (std::exception& e) {
44786       {
44787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44788       };
44789     } catch (Dali::DaliException e) {
44790       {
44791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44792       };
44793     } catch (...) {
44794       {
44795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44796       };
44797     }
44798   }
44799
44800   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44801   return jresult;
44802 }
44803
44804
44805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44806   void * jresult ;
44807   Dali::BaseHandle arg1 ;
44808   Dali::BaseHandle *argp1 ;
44809   Dali::CameraActor result;
44810
44811   argp1 = (Dali::BaseHandle *)jarg1;
44812   if (!argp1) {
44813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44814     return 0;
44815   }
44816   arg1 = *argp1;
44817   {
44818     try {
44819       result = Dali::CameraActor::DownCast(arg1);
44820     } catch (std::out_of_range& e) {
44821       {
44822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44823       };
44824     } catch (std::exception& e) {
44825       {
44826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44827       };
44828     } catch (Dali::DaliException e) {
44829       {
44830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44831       };
44832     } catch (...) {
44833       {
44834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44835       };
44836     }
44837   }
44838
44839   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44840   return jresult;
44841 }
44842
44843
44844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44845   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44846
44847   arg1 = (Dali::CameraActor *)jarg1;
44848   {
44849     try {
44850       delete arg1;
44851     } catch (std::out_of_range& e) {
44852       {
44853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44854       };
44855     } catch (std::exception& e) {
44856       {
44857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44858       };
44859     } catch (Dali::DaliException e) {
44860       {
44861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44862       };
44863     } catch (...) {
44864       {
44865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44866       };
44867     }
44868   }
44869
44870 }
44871
44872
44873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44874   void * jresult ;
44875   Dali::CameraActor *arg1 = 0 ;
44876   Dali::CameraActor *result = 0 ;
44877
44878   arg1 = (Dali::CameraActor *)jarg1;
44879   if (!arg1) {
44880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44881     return 0;
44882   }
44883   {
44884     try {
44885       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44886     } catch (std::out_of_range& e) {
44887       {
44888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44889       };
44890     } catch (std::exception& e) {
44891       {
44892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44893       };
44894     } catch (Dali::DaliException e) {
44895       {
44896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44897       };
44898     } catch (...) {
44899       {
44900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44901       };
44902     }
44903   }
44904
44905   jresult = (void *)result;
44906   return jresult;
44907 }
44908
44909
44910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44911   void * jresult ;
44912   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44913   Dali::CameraActor *arg2 = 0 ;
44914   Dali::CameraActor *result = 0 ;
44915
44916   arg1 = (Dali::CameraActor *)jarg1;
44917   arg2 = (Dali::CameraActor *)jarg2;
44918   if (!arg2) {
44919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44920     return 0;
44921   }
44922   {
44923     try {
44924       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44925     } catch (std::out_of_range& e) {
44926       {
44927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44928       };
44929     } catch (std::exception& e) {
44930       {
44931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44932       };
44933     } catch (Dali::DaliException e) {
44934       {
44935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44936       };
44937     } catch (...) {
44938       {
44939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44940       };
44941     }
44942   }
44943
44944   jresult = (void *)result;
44945   return jresult;
44946 }
44947
44948
44949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44950   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44951   Dali::Camera::Type arg2 ;
44952
44953   arg1 = (Dali::CameraActor *)jarg1;
44954   arg2 = (Dali::Camera::Type)jarg2;
44955   {
44956     try {
44957       (arg1)->SetType(arg2);
44958     } catch (std::out_of_range& e) {
44959       {
44960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44961       };
44962     } catch (std::exception& e) {
44963       {
44964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44965       };
44966     } catch (Dali::DaliException e) {
44967       {
44968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44969       };
44970     } catch (...) {
44971       {
44972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44973       };
44974     }
44975   }
44976
44977 }
44978
44979
44980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44981   int jresult ;
44982   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44983   Dali::Camera::Type result;
44984
44985   arg1 = (Dali::CameraActor *)jarg1;
44986   {
44987     try {
44988       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44989     } catch (std::out_of_range& e) {
44990       {
44991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44992       };
44993     } catch (std::exception& e) {
44994       {
44995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44996       };
44997     } catch (Dali::DaliException e) {
44998       {
44999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45000       };
45001     } catch (...) {
45002       {
45003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45004       };
45005     }
45006   }
45007
45008   jresult = (int)result;
45009   return jresult;
45010 }
45011
45012
45013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
45014   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45015   Dali::Camera::ProjectionMode arg2 ;
45016
45017   arg1 = (Dali::CameraActor *)jarg1;
45018   arg2 = (Dali::Camera::ProjectionMode)jarg2;
45019   {
45020     try {
45021       (arg1)->SetProjectionMode(arg2);
45022     } catch (std::out_of_range& e) {
45023       {
45024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45025       };
45026     } catch (std::exception& e) {
45027       {
45028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45029       };
45030     } catch (Dali::DaliException e) {
45031       {
45032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45033       };
45034     } catch (...) {
45035       {
45036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45037       };
45038     }
45039   }
45040
45041 }
45042
45043
45044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
45045   int jresult ;
45046   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45047   Dali::Camera::ProjectionMode result;
45048
45049   arg1 = (Dali::CameraActor *)jarg1;
45050   {
45051     try {
45052       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
45053     } catch (std::out_of_range& e) {
45054       {
45055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45056       };
45057     } catch (std::exception& e) {
45058       {
45059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45060       };
45061     } catch (Dali::DaliException e) {
45062       {
45063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45064       };
45065     } catch (...) {
45066       {
45067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45068       };
45069     }
45070   }
45071
45072   jresult = (int)result;
45073   return jresult;
45074 }
45075
45076
45077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45078   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45079   float arg2 ;
45080
45081   arg1 = (Dali::CameraActor *)jarg1;
45082   arg2 = (float)jarg2;
45083   {
45084     try {
45085       (arg1)->SetFieldOfView(arg2);
45086     } catch (std::out_of_range& e) {
45087       {
45088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45089       };
45090     } catch (std::exception& e) {
45091       {
45092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45093       };
45094     } catch (Dali::DaliException e) {
45095       {
45096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45097       };
45098     } catch (...) {
45099       {
45100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45101       };
45102     }
45103   }
45104
45105 }
45106
45107
45108 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45109   float jresult ;
45110   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45111   float result;
45112
45113   arg1 = (Dali::CameraActor *)jarg1;
45114   {
45115     try {
45116       result = (float)(arg1)->GetFieldOfView();
45117     } catch (std::out_of_range& e) {
45118       {
45119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45120       };
45121     } catch (std::exception& e) {
45122       {
45123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45124       };
45125     } catch (Dali::DaliException e) {
45126       {
45127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45128       };
45129     } catch (...) {
45130       {
45131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45132       };
45133     }
45134   }
45135
45136   jresult = result;
45137   return jresult;
45138 }
45139
45140
45141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45142   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45143   float arg2 ;
45144
45145   arg1 = (Dali::CameraActor *)jarg1;
45146   arg2 = (float)jarg2;
45147   {
45148     try {
45149       (arg1)->SetAspectRatio(arg2);
45150     } catch (std::out_of_range& e) {
45151       {
45152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45153       };
45154     } catch (std::exception& e) {
45155       {
45156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45157       };
45158     } catch (Dali::DaliException e) {
45159       {
45160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45161       };
45162     } catch (...) {
45163       {
45164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45165       };
45166     }
45167   }
45168
45169 }
45170
45171
45172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45173   float jresult ;
45174   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45175   float result;
45176
45177   arg1 = (Dali::CameraActor *)jarg1;
45178   {
45179     try {
45180       result = (float)(arg1)->GetAspectRatio();
45181     } catch (std::out_of_range& e) {
45182       {
45183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45184       };
45185     } catch (std::exception& e) {
45186       {
45187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45188       };
45189     } catch (Dali::DaliException e) {
45190       {
45191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45192       };
45193     } catch (...) {
45194       {
45195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45196       };
45197     }
45198   }
45199
45200   jresult = result;
45201   return jresult;
45202 }
45203
45204
45205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45206   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45207   float arg2 ;
45208
45209   arg1 = (Dali::CameraActor *)jarg1;
45210   arg2 = (float)jarg2;
45211   {
45212     try {
45213       (arg1)->SetNearClippingPlane(arg2);
45214     } catch (std::out_of_range& e) {
45215       {
45216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45217       };
45218     } catch (std::exception& e) {
45219       {
45220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45221       };
45222     } catch (Dali::DaliException e) {
45223       {
45224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45225       };
45226     } catch (...) {
45227       {
45228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45229       };
45230     }
45231   }
45232
45233 }
45234
45235
45236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45237   float jresult ;
45238   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45239   float result;
45240
45241   arg1 = (Dali::CameraActor *)jarg1;
45242   {
45243     try {
45244       result = (float)(arg1)->GetNearClippingPlane();
45245     } catch (std::out_of_range& e) {
45246       {
45247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45248       };
45249     } catch (std::exception& e) {
45250       {
45251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45252       };
45253     } catch (Dali::DaliException e) {
45254       {
45255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45256       };
45257     } catch (...) {
45258       {
45259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45260       };
45261     }
45262   }
45263
45264   jresult = result;
45265   return jresult;
45266 }
45267
45268
45269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45270   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45271   float arg2 ;
45272
45273   arg1 = (Dali::CameraActor *)jarg1;
45274   arg2 = (float)jarg2;
45275   {
45276     try {
45277       (arg1)->SetFarClippingPlane(arg2);
45278     } catch (std::out_of_range& e) {
45279       {
45280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45281       };
45282     } catch (std::exception& e) {
45283       {
45284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45285       };
45286     } catch (Dali::DaliException e) {
45287       {
45288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45289       };
45290     } catch (...) {
45291       {
45292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45293       };
45294     }
45295   }
45296
45297 }
45298
45299
45300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45301   float jresult ;
45302   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45303   float result;
45304
45305   arg1 = (Dali::CameraActor *)jarg1;
45306   {
45307     try {
45308       result = (float)(arg1)->GetFarClippingPlane();
45309     } catch (std::out_of_range& e) {
45310       {
45311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45312       };
45313     } catch (std::exception& e) {
45314       {
45315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45316       };
45317     } catch (Dali::DaliException e) {
45318       {
45319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45320       };
45321     } catch (...) {
45322       {
45323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45324       };
45325     }
45326   }
45327
45328   jresult = result;
45329   return jresult;
45330 }
45331
45332
45333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45334   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45335   Dali::Vector3 *arg2 = 0 ;
45336
45337   arg1 = (Dali::CameraActor *)jarg1;
45338   arg2 = (Dali::Vector3 *)jarg2;
45339   if (!arg2) {
45340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45341     return ;
45342   }
45343   {
45344     try {
45345       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45346     } catch (std::out_of_range& e) {
45347       {
45348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45349       };
45350     } catch (std::exception& e) {
45351       {
45352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45353       };
45354     } catch (Dali::DaliException e) {
45355       {
45356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45357       };
45358     } catch (...) {
45359       {
45360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45361       };
45362     }
45363   }
45364
45365 }
45366
45367
45368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45369   void * jresult ;
45370   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45371   Dali::Vector3 result;
45372
45373   arg1 = (Dali::CameraActor *)jarg1;
45374   {
45375     try {
45376       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45377     } catch (std::out_of_range& e) {
45378       {
45379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45380       };
45381     } catch (std::exception& e) {
45382       {
45383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45384       };
45385     } catch (Dali::DaliException e) {
45386       {
45387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45388       };
45389     } catch (...) {
45390       {
45391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45392       };
45393     }
45394   }
45395
45396   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45397   return jresult;
45398 }
45399
45400
45401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45402   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45403   bool arg2 ;
45404
45405   arg1 = (Dali::CameraActor *)jarg1;
45406   arg2 = jarg2 ? true : false;
45407   {
45408     try {
45409       (arg1)->SetInvertYAxis(arg2);
45410     } catch (std::out_of_range& e) {
45411       {
45412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45413       };
45414     } catch (std::exception& e) {
45415       {
45416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45417       };
45418     } catch (Dali::DaliException e) {
45419       {
45420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45421       };
45422     } catch (...) {
45423       {
45424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45425       };
45426     }
45427   }
45428
45429 }
45430
45431
45432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45433   unsigned int jresult ;
45434   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45435   bool result;
45436
45437   arg1 = (Dali::CameraActor *)jarg1;
45438   {
45439     try {
45440       result = (bool)(arg1)->GetInvertYAxis();
45441     } catch (std::out_of_range& e) {
45442       {
45443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45444       };
45445     } catch (std::exception& e) {
45446       {
45447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45448       };
45449     } catch (Dali::DaliException e) {
45450       {
45451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45452       };
45453     } catch (...) {
45454       {
45455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45456       };
45457     }
45458   }
45459
45460   jresult = result;
45461   return jresult;
45462 }
45463
45464
45465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45466   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45467   Dali::Size *arg2 = 0 ;
45468
45469   arg1 = (Dali::CameraActor *)jarg1;
45470   arg2 = (Dali::Size *)jarg2;
45471   if (!arg2) {
45472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45473     return ;
45474   }
45475   {
45476     try {
45477       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45478     } catch (std::out_of_range& e) {
45479       {
45480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45481       };
45482     } catch (std::exception& e) {
45483       {
45484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45485       };
45486     } catch (Dali::DaliException e) {
45487       {
45488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45489       };
45490     } catch (...) {
45491       {
45492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45493       };
45494     }
45495   }
45496
45497 }
45498
45499
45500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45501   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45502   Dali::Size *arg2 = 0 ;
45503
45504   arg1 = (Dali::CameraActor *)jarg1;
45505   arg2 = (Dali::Size *)jarg2;
45506   if (!arg2) {
45507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45508     return ;
45509   }
45510   {
45511     try {
45512       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45513     } catch (std::out_of_range& e) {
45514       {
45515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45516       };
45517     } catch (std::exception& e) {
45518       {
45519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45520       };
45521     } catch (Dali::DaliException e) {
45522       {
45523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45524       };
45525     } catch (...) {
45526       {
45527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45528       };
45529     }
45530   }
45531
45532 }
45533
45534
45535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45536   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45537   float arg2 ;
45538   float arg3 ;
45539   float arg4 ;
45540   float arg5 ;
45541   float arg6 ;
45542   float arg7 ;
45543
45544   arg1 = (Dali::CameraActor *)jarg1;
45545   arg2 = (float)jarg2;
45546   arg3 = (float)jarg3;
45547   arg4 = (float)jarg4;
45548   arg5 = (float)jarg5;
45549   arg6 = (float)jarg6;
45550   arg7 = (float)jarg7;
45551   {
45552     try {
45553       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
45554     } catch (std::out_of_range& e) {
45555       {
45556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45557       };
45558     } catch (std::exception& e) {
45559       {
45560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45561       };
45562     } catch (Dali::DaliException e) {
45563       {
45564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45565       };
45566     } catch (...) {
45567       {
45568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45569       };
45570     }
45571   }
45572
45573 }
45574
45575
45576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
45577   void * jresult ;
45578   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45579
45580   {
45581     try {
45582       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
45583     } catch (std::out_of_range& e) {
45584       {
45585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45586       };
45587     } catch (std::exception& e) {
45588       {
45589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45590       };
45591     } catch (Dali::DaliException e) {
45592       {
45593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45594       };
45595     } catch (...) {
45596       {
45597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45598       };
45599     }
45600   }
45601
45602   jresult = (void *)result;
45603   return jresult;
45604 }
45605
45606
45607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
45608   void * jresult ;
45609   std::string arg1 ;
45610   Dali::Property::Value arg2 ;
45611   Dali::Property::Value *argp2 ;
45612   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45613
45614   if (!jarg1) {
45615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45616     return 0;
45617   }
45618   (&arg1)->assign(jarg1);
45619   argp2 = (Dali::Property::Value *)jarg2;
45620   if (!argp2) {
45621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
45622     return 0;
45623   }
45624   arg2 = *argp2;
45625   {
45626     try {
45627       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
45628     } catch (std::out_of_range& e) {
45629       {
45630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45631       };
45632     } catch (std::exception& e) {
45633       {
45634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45635       };
45636     } catch (Dali::DaliException e) {
45637       {
45638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45639       };
45640     } catch (...) {
45641       {
45642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45643       };
45644     }
45645   }
45646
45647   jresult = (void *)result;
45648   return jresult;
45649 }
45650
45651
45652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
45653   void * jresult ;
45654   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
45655   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45656
45657   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45658   if (!arg1) {
45659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
45660     return 0;
45661   }
45662   {
45663     try {
45664       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);
45665     } catch (std::out_of_range& e) {
45666       {
45667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (std::exception& e) {
45670       {
45671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45672       };
45673     } catch (Dali::DaliException e) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45676       };
45677     } catch (...) {
45678       {
45679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45680       };
45681     }
45682   }
45683
45684   jresult = (void *)result;
45685   return jresult;
45686 }
45687
45688
45689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
45690   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45691   std::string *arg2 = 0 ;
45692
45693   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45694   if (!jarg2) {
45695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45696     return ;
45697   }
45698   std::string arg2_str(jarg2);
45699   arg2 = &arg2_str;
45700   if (arg1) (arg1)->first = *arg2;
45701
45702   //argout typemap for const std::string&
45703
45704 }
45705
45706
45707 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
45708   char * jresult ;
45709   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45710   std::string *result = 0 ;
45711
45712   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45713   result = (std::string *) & ((arg1)->first);
45714   jresult = SWIG_csharp_string_callback(result->c_str());
45715   return jresult;
45716 }
45717
45718
45719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
45720   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45721   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
45722
45723   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45724   arg2 = (Dali::Property::Value *)jarg2;
45725   if (arg1) (arg1)->second = *arg2;
45726 }
45727
45728
45729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
45730   void * jresult ;
45731   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45732   Dali::Property::Value *result = 0 ;
45733
45734   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45735   result = (Dali::Property::Value *)& ((arg1)->second);
45736   jresult = (void *)result;
45737   return jresult;
45738 }
45739
45740
45741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
45742   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45743
45744   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45745   {
45746     try {
45747       delete arg1;
45748     } catch (std::out_of_range& e) {
45749       {
45750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45751       };
45752     } catch (std::exception& e) {
45753       {
45754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45755       };
45756     } catch (Dali::DaliException e) {
45757       {
45758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45759       };
45760     } catch (...) {
45761       {
45762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45763       };
45764     }
45765   }
45766
45767 }
45768
45769
45770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
45771   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45772
45773   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45774   {
45775     try {
45776       (arg1)->clear();
45777     } catch (std::out_of_range& e) {
45778       {
45779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45780       };
45781     } catch (std::exception& e) {
45782       {
45783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45784       };
45785     } catch (Dali::DaliException e) {
45786       {
45787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45788       };
45789     } catch (...) {
45790       {
45791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45792       };
45793     }
45794   }
45795
45796 }
45797
45798
45799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
45800   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45801   Dali::TouchPoint *arg2 = 0 ;
45802
45803   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45804   arg2 = (Dali::TouchPoint *)jarg2;
45805   if (!arg2) {
45806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45807     return ;
45808   }
45809   {
45810     try {
45811       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
45812     } catch (std::out_of_range& e) {
45813       {
45814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45815       };
45816     } catch (std::exception& e) {
45817       {
45818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45819       };
45820     } catch (Dali::DaliException e) {
45821       {
45822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45823       };
45824     } catch (...) {
45825       {
45826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45827       };
45828     }
45829   }
45830
45831 }
45832
45833
45834 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
45835   unsigned long jresult ;
45836   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45837   std::vector< Dali::TouchPoint >::size_type result;
45838
45839   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45840   {
45841     try {
45842       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
45843     } catch (std::out_of_range& e) {
45844       {
45845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45846       };
45847     } catch (std::exception& e) {
45848       {
45849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45850       };
45851     } catch (Dali::DaliException e) {
45852       {
45853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45854       };
45855     } catch (...) {
45856       {
45857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45858       };
45859     }
45860   }
45861
45862   jresult = (unsigned long)result;
45863   return jresult;
45864 }
45865
45866
45867 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
45868   unsigned long jresult ;
45869   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45870   std::vector< Dali::TouchPoint >::size_type result;
45871
45872   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45873   {
45874     try {
45875       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
45876     } catch (std::out_of_range& e) {
45877       {
45878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45879       };
45880     } catch (std::exception& e) {
45881       {
45882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45883       };
45884     } catch (Dali::DaliException e) {
45885       {
45886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45887       };
45888     } catch (...) {
45889       {
45890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45891       };
45892     }
45893   }
45894
45895   jresult = (unsigned long)result;
45896   return jresult;
45897 }
45898
45899
45900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
45901   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45902   std::vector< Dali::TouchPoint >::size_type arg2 ;
45903
45904   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45905   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
45906   {
45907     try {
45908       (arg1)->reserve(arg2);
45909     } catch (std::out_of_range& e) {
45910       {
45911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45912       };
45913     } catch (std::exception& e) {
45914       {
45915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45916       };
45917     } catch (Dali::DaliException e) {
45918       {
45919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45920       };
45921     } catch (...) {
45922       {
45923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45924       };
45925     }
45926   }
45927
45928 }
45929
45930
45931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
45932   void * jresult ;
45933   std::vector< Dali::TouchPoint > *result = 0 ;
45934
45935   {
45936     try {
45937       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
45938     } catch (std::out_of_range& e) {
45939       {
45940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45941       };
45942     } catch (std::exception& e) {
45943       {
45944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45945       };
45946     } catch (Dali::DaliException e) {
45947       {
45948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45949       };
45950     } catch (...) {
45951       {
45952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45953       };
45954     }
45955   }
45956
45957   jresult = (void *)result;
45958   return jresult;
45959 }
45960
45961
45962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45963   void * jresult ;
45964   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45965   std::vector< Dali::TouchPoint > *result = 0 ;
45966
45967   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45968   if (!arg1) {
45969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45970     return 0;
45971   }
45972   {
45973     try {
45974       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45975     } catch (std::out_of_range& e) {
45976       {
45977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45978       };
45979     } catch (std::exception& e) {
45980       {
45981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45982       };
45983     } catch (Dali::DaliException e) {
45984       {
45985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45986       };
45987     } catch (...) {
45988       {
45989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45990       };
45991     }
45992   }
45993
45994   jresult = (void *)result;
45995   return jresult;
45996 }
45997
45998
45999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
46000   void * jresult ;
46001   int arg1 ;
46002   std::vector< Dali::TouchPoint > *result = 0 ;
46003
46004   arg1 = (int)jarg1;
46005   {
46006     try {
46007       try {
46008         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
46009       }
46010       catch(std::out_of_range &_e) {
46011         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46012         return 0;
46013       }
46014
46015     } catch (std::out_of_range& e) {
46016       {
46017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46018       };
46019     } catch (std::exception& e) {
46020       {
46021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46022       };
46023     } catch (Dali::DaliException e) {
46024       {
46025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46026       };
46027     } catch (...) {
46028       {
46029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46030       };
46031     }
46032   }
46033
46034   jresult = (void *)result;
46035   return jresult;
46036 }
46037
46038
46039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
46040   void * jresult ;
46041   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46042   int arg2 ;
46043   SwigValueWrapper< Dali::TouchPoint > result;
46044
46045   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46046   arg2 = (int)jarg2;
46047   {
46048     try {
46049       try {
46050         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
46051       }
46052       catch(std::out_of_range &_e) {
46053         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46054         return 0;
46055       }
46056
46057     } catch (std::out_of_range& e) {
46058       {
46059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46060       };
46061     } catch (std::exception& e) {
46062       {
46063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46064       };
46065     } catch (Dali::DaliException e) {
46066       {
46067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46068       };
46069     } catch (...) {
46070       {
46071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46072       };
46073     }
46074   }
46075
46076   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46077   return jresult;
46078 }
46079
46080
46081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46082   void * jresult ;
46083   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46084   int arg2 ;
46085   Dali::TouchPoint *result = 0 ;
46086
46087   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46088   arg2 = (int)jarg2;
46089   {
46090     try {
46091       try {
46092         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46093       }
46094       catch(std::out_of_range &_e) {
46095         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46096         return 0;
46097       }
46098
46099     } catch (std::out_of_range& e) {
46100       {
46101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46102       };
46103     } catch (std::exception& e) {
46104       {
46105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46106       };
46107     } catch (Dali::DaliException e) {
46108       {
46109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46110       };
46111     } catch (...) {
46112       {
46113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46114       };
46115     }
46116   }
46117
46118   jresult = (void *)result;
46119   return jresult;
46120 }
46121
46122
46123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46124   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46125   int arg2 ;
46126   Dali::TouchPoint *arg3 = 0 ;
46127
46128   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46129   arg2 = (int)jarg2;
46130   arg3 = (Dali::TouchPoint *)jarg3;
46131   if (!arg3) {
46132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46133     return ;
46134   }
46135   {
46136     try {
46137       try {
46138         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46139       }
46140       catch(std::out_of_range &_e) {
46141         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46142         return ;
46143       }
46144
46145     } catch (std::out_of_range& e) {
46146       {
46147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46148       };
46149     } catch (std::exception& e) {
46150       {
46151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46152       };
46153     } catch (Dali::DaliException e) {
46154       {
46155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46156       };
46157     } catch (...) {
46158       {
46159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46160       };
46161     }
46162   }
46163
46164 }
46165
46166
46167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46168   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46169   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46170
46171   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46172   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46173   if (!arg2) {
46174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46175     return ;
46176   }
46177   {
46178     try {
46179       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46180     } catch (std::out_of_range& e) {
46181       {
46182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46183       };
46184     } catch (std::exception& e) {
46185       {
46186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46187       };
46188     } catch (Dali::DaliException e) {
46189       {
46190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46191       };
46192     } catch (...) {
46193       {
46194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46195       };
46196     }
46197   }
46198
46199 }
46200
46201
46202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46203   void * jresult ;
46204   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46205   int arg2 ;
46206   int arg3 ;
46207   std::vector< Dali::TouchPoint > *result = 0 ;
46208
46209   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46210   arg2 = (int)jarg2;
46211   arg3 = (int)jarg3;
46212   {
46213     try {
46214       try {
46215         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46216       }
46217       catch(std::out_of_range &_e) {
46218         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46219         return 0;
46220       }
46221       catch(std::invalid_argument &_e) {
46222         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46223         return 0;
46224       }
46225
46226     } catch (std::out_of_range& e) {
46227       {
46228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46229       };
46230     } catch (std::exception& e) {
46231       {
46232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46233       };
46234     } catch (Dali::DaliException e) {
46235       {
46236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46237       };
46238     } catch (...) {
46239       {
46240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46241       };
46242     }
46243   }
46244
46245   jresult = (void *)result;
46246   return jresult;
46247 }
46248
46249
46250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46251   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46252   int arg2 ;
46253   Dali::TouchPoint *arg3 = 0 ;
46254
46255   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46256   arg2 = (int)jarg2;
46257   arg3 = (Dali::TouchPoint *)jarg3;
46258   if (!arg3) {
46259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46260     return ;
46261   }
46262   {
46263     try {
46264       try {
46265         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46266       }
46267       catch(std::out_of_range &_e) {
46268         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46269         return ;
46270       }
46271
46272     } catch (std::out_of_range& e) {
46273       {
46274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46275       };
46276     } catch (std::exception& e) {
46277       {
46278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46279       };
46280     } catch (Dali::DaliException e) {
46281       {
46282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46283       };
46284     } catch (...) {
46285       {
46286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46287       };
46288     }
46289   }
46290
46291 }
46292
46293
46294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46295   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46296   int arg2 ;
46297   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46298
46299   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46300   arg2 = (int)jarg2;
46301   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46302   if (!arg3) {
46303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46304     return ;
46305   }
46306   {
46307     try {
46308       try {
46309         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46310       }
46311       catch(std::out_of_range &_e) {
46312         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46313         return ;
46314       }
46315
46316     } catch (std::out_of_range& e) {
46317       {
46318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46319       };
46320     } catch (std::exception& e) {
46321       {
46322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46323       };
46324     } catch (Dali::DaliException e) {
46325       {
46326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46327       };
46328     } catch (...) {
46329       {
46330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46331       };
46332     }
46333   }
46334
46335 }
46336
46337
46338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46339   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46340   int arg2 ;
46341
46342   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46343   arg2 = (int)jarg2;
46344   {
46345     try {
46346       try {
46347         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46348       }
46349       catch(std::out_of_range &_e) {
46350         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46351         return ;
46352       }
46353
46354     } catch (std::out_of_range& e) {
46355       {
46356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46357       };
46358     } catch (std::exception& e) {
46359       {
46360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46361       };
46362     } catch (Dali::DaliException e) {
46363       {
46364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46365       };
46366     } catch (...) {
46367       {
46368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46369       };
46370     }
46371   }
46372
46373 }
46374
46375
46376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46377   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46378   int arg2 ;
46379   int arg3 ;
46380
46381   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46382   arg2 = (int)jarg2;
46383   arg3 = (int)jarg3;
46384   {
46385     try {
46386       try {
46387         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46388       }
46389       catch(std::out_of_range &_e) {
46390         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46391         return ;
46392       }
46393       catch(std::invalid_argument &_e) {
46394         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46395         return ;
46396       }
46397
46398     } catch (std::out_of_range& e) {
46399       {
46400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46401       };
46402     } catch (std::exception& e) {
46403       {
46404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46405       };
46406     } catch (Dali::DaliException e) {
46407       {
46408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46409       };
46410     } catch (...) {
46411       {
46412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46413       };
46414     }
46415   }
46416
46417 }
46418
46419
46420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46421   void * jresult ;
46422   Dali::TouchPoint *arg1 = 0 ;
46423   int arg2 ;
46424   std::vector< Dali::TouchPoint > *result = 0 ;
46425
46426   arg1 = (Dali::TouchPoint *)jarg1;
46427   if (!arg1) {
46428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46429     return 0;
46430   }
46431   arg2 = (int)jarg2;
46432   {
46433     try {
46434       try {
46435         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46436       }
46437       catch(std::out_of_range &_e) {
46438         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46439         return 0;
46440       }
46441
46442     } catch (std::out_of_range& e) {
46443       {
46444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46445       };
46446     } catch (std::exception& e) {
46447       {
46448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46449       };
46450     } catch (Dali::DaliException e) {
46451       {
46452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46453       };
46454     } catch (...) {
46455       {
46456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46457       };
46458     }
46459   }
46460
46461   jresult = (void *)result;
46462   return jresult;
46463 }
46464
46465
46466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46467   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46468
46469   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46470   {
46471     try {
46472       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46473     } catch (std::out_of_range& e) {
46474       {
46475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46476       };
46477     } catch (std::exception& e) {
46478       {
46479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46480       };
46481     } catch (Dali::DaliException e) {
46482       {
46483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46484       };
46485     } catch (...) {
46486       {
46487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46488       };
46489     }
46490   }
46491
46492 }
46493
46494
46495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46496   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46497   int arg2 ;
46498   int arg3 ;
46499
46500   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46501   arg2 = (int)jarg2;
46502   arg3 = (int)jarg3;
46503   {
46504     try {
46505       try {
46506         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46507       }
46508       catch(std::out_of_range &_e) {
46509         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46510         return ;
46511       }
46512       catch(std::invalid_argument &_e) {
46513         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46514         return ;
46515       }
46516
46517     } catch (std::out_of_range& e) {
46518       {
46519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46520       };
46521     } catch (std::exception& e) {
46522       {
46523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46524       };
46525     } catch (Dali::DaliException e) {
46526       {
46527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46528       };
46529     } catch (...) {
46530       {
46531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46532       };
46533     }
46534   }
46535
46536 }
46537
46538
46539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
46540   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46541   int arg2 ;
46542   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46543
46544   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46545   arg2 = (int)jarg2;
46546   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46547   if (!arg3) {
46548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46549     return ;
46550   }
46551   {
46552     try {
46553       try {
46554         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46555       }
46556       catch(std::out_of_range &_e) {
46557         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46558         return ;
46559       }
46560
46561     } catch (std::out_of_range& e) {
46562       {
46563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46564       };
46565     } catch (std::exception& e) {
46566       {
46567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46568       };
46569     } catch (Dali::DaliException e) {
46570       {
46571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46572       };
46573     } catch (...) {
46574       {
46575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46576       };
46577     }
46578   }
46579
46580 }
46581
46582
46583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
46584   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46585
46586   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46587   {
46588     try {
46589       delete arg1;
46590     } catch (std::out_of_range& e) {
46591       {
46592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46593       };
46594     } catch (std::exception& e) {
46595       {
46596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46597       };
46598     } catch (Dali::DaliException e) {
46599       {
46600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46601       };
46602     } catch (...) {
46603       {
46604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46605       };
46606     }
46607   }
46608
46609 }
46610
46611
46612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
46613   void * jresult ;
46614   Dali::Rect< int > *result = 0 ;
46615
46616   {
46617     try {
46618       result = (Dali::Rect< int > *)new Dali::Rect< int >();
46619     } catch (std::out_of_range& e) {
46620       {
46621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46622       };
46623     } catch (std::exception& e) {
46624       {
46625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46626       };
46627     } catch (Dali::DaliException e) {
46628       {
46629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46630       };
46631     } catch (...) {
46632       {
46633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46634       };
46635     }
46636   }
46637
46638   jresult = (void *)result;
46639   return jresult;
46640 }
46641
46642
46643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
46644   void * jresult ;
46645   int arg1 ;
46646   int arg2 ;
46647   int arg3 ;
46648   int arg4 ;
46649   Dali::Rect< int > *result = 0 ;
46650
46651   arg1 = (int)jarg1;
46652   arg2 = (int)jarg2;
46653   arg3 = (int)jarg3;
46654   arg4 = (int)jarg4;
46655   {
46656     try {
46657       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
46658     } catch (std::out_of_range& e) {
46659       {
46660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46661       };
46662     } catch (std::exception& e) {
46663       {
46664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46665       };
46666     } catch (Dali::DaliException e) {
46667       {
46668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46669       };
46670     } catch (...) {
46671       {
46672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46673       };
46674     }
46675   }
46676
46677   jresult = (void *)result;
46678   return jresult;
46679 }
46680
46681
46682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
46683   void * jresult ;
46684   Dali::Rect< int > *arg1 = 0 ;
46685   Dali::Rect< int > *result = 0 ;
46686
46687   arg1 = (Dali::Rect< int > *)jarg1;
46688   if (!arg1) {
46689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46690     return 0;
46691   }
46692   {
46693     try {
46694       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
46695     } catch (std::out_of_range& e) {
46696       {
46697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46698       };
46699     } catch (std::exception& e) {
46700       {
46701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46702       };
46703     } catch (Dali::DaliException e) {
46704       {
46705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46706       };
46707     } catch (...) {
46708       {
46709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46710       };
46711     }
46712   }
46713
46714   jresult = (void *)result;
46715   return jresult;
46716 }
46717
46718
46719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
46720   void * jresult ;
46721   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46722   Dali::Rect< int > *arg2 = 0 ;
46723   Dali::Rect< int > *result = 0 ;
46724
46725   arg1 = (Dali::Rect< int > *)jarg1;
46726   arg2 = (Dali::Rect< int > *)jarg2;
46727   if (!arg2) {
46728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46729     return 0;
46730   }
46731   {
46732     try {
46733       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
46734     } catch (std::out_of_range& e) {
46735       {
46736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46737       };
46738     } catch (std::exception& e) {
46739       {
46740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46741       };
46742     } catch (Dali::DaliException e) {
46743       {
46744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46745       };
46746     } catch (...) {
46747       {
46748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46749       };
46750     }
46751   }
46752
46753   jresult = (void *)result;
46754   return jresult;
46755 }
46756
46757
46758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
46759   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46760   int arg2 ;
46761   int arg3 ;
46762   int arg4 ;
46763   int arg5 ;
46764
46765   arg1 = (Dali::Rect< int > *)jarg1;
46766   arg2 = (int)jarg2;
46767   arg3 = (int)jarg3;
46768   arg4 = (int)jarg4;
46769   arg5 = (int)jarg5;
46770   {
46771     try {
46772       (arg1)->Set(arg2,arg3,arg4,arg5);
46773     } catch (std::out_of_range& e) {
46774       {
46775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46776       };
46777     } catch (std::exception& e) {
46778       {
46779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46780       };
46781     } catch (Dali::DaliException e) {
46782       {
46783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46784       };
46785     } catch (...) {
46786       {
46787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46788       };
46789     }
46790   }
46791
46792 }
46793
46794
46795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
46796   unsigned int jresult ;
46797   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46798   bool result;
46799
46800   arg1 = (Dali::Rect< int > *)jarg1;
46801   {
46802     try {
46803       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
46804     } catch (std::out_of_range& e) {
46805       {
46806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46807       };
46808     } catch (std::exception& e) {
46809       {
46810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46811       };
46812     } catch (Dali::DaliException e) {
46813       {
46814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46815       };
46816     } catch (...) {
46817       {
46818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46819       };
46820     }
46821   }
46822
46823   jresult = result;
46824   return jresult;
46825 }
46826
46827
46828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
46829   int jresult ;
46830   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46831   int result;
46832
46833   arg1 = (Dali::Rect< int > *)jarg1;
46834   {
46835     try {
46836       result = (int)((Dali::Rect< int > const *)arg1)->Left();
46837     } catch (std::out_of_range& e) {
46838       {
46839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46840       };
46841     } catch (std::exception& e) {
46842       {
46843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46844       };
46845     } catch (Dali::DaliException e) {
46846       {
46847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46848       };
46849     } catch (...) {
46850       {
46851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46852       };
46853     }
46854   }
46855
46856   jresult = result;
46857   return jresult;
46858 }
46859
46860
46861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
46862   int jresult ;
46863   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46864   int result;
46865
46866   arg1 = (Dali::Rect< int > *)jarg1;
46867   {
46868     try {
46869       result = (int)((Dali::Rect< int > const *)arg1)->Right();
46870     } catch (std::out_of_range& e) {
46871       {
46872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46873       };
46874     } catch (std::exception& e) {
46875       {
46876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46877       };
46878     } catch (Dali::DaliException e) {
46879       {
46880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46881       };
46882     } catch (...) {
46883       {
46884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46885       };
46886     }
46887   }
46888
46889   jresult = result;
46890   return jresult;
46891 }
46892
46893
46894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
46895   int jresult ;
46896   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46897   int result;
46898
46899   arg1 = (Dali::Rect< int > *)jarg1;
46900   {
46901     try {
46902       result = (int)((Dali::Rect< int > const *)arg1)->Top();
46903     } catch (std::out_of_range& e) {
46904       {
46905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46906       };
46907     } catch (std::exception& e) {
46908       {
46909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46910       };
46911     } catch (Dali::DaliException e) {
46912       {
46913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46914       };
46915     } catch (...) {
46916       {
46917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46918       };
46919     }
46920   }
46921
46922   jresult = result;
46923   return jresult;
46924 }
46925
46926
46927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
46928   int jresult ;
46929   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46930   int result;
46931
46932   arg1 = (Dali::Rect< int > *)jarg1;
46933   {
46934     try {
46935       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
46936     } catch (std::out_of_range& e) {
46937       {
46938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46939       };
46940     } catch (std::exception& e) {
46941       {
46942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46943       };
46944     } catch (Dali::DaliException e) {
46945       {
46946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46947       };
46948     } catch (...) {
46949       {
46950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46951       };
46952     }
46953   }
46954
46955   jresult = result;
46956   return jresult;
46957 }
46958
46959
46960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
46961   int jresult ;
46962   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46963   int result;
46964
46965   arg1 = (Dali::Rect< int > *)jarg1;
46966   {
46967     try {
46968       result = (int)((Dali::Rect< int > const *)arg1)->Area();
46969     } catch (std::out_of_range& e) {
46970       {
46971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46972       };
46973     } catch (std::exception& e) {
46974       {
46975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46976       };
46977     } catch (Dali::DaliException e) {
46978       {
46979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46980       };
46981     } catch (...) {
46982       {
46983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46984       };
46985     }
46986   }
46987
46988   jresult = result;
46989   return jresult;
46990 }
46991
46992
46993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
46994   unsigned int jresult ;
46995   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46996   Dali::Rect< int > *arg2 = 0 ;
46997   bool result;
46998
46999   arg1 = (Dali::Rect< int > *)jarg1;
47000   arg2 = (Dali::Rect< int > *)jarg2;
47001   if (!arg2) {
47002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47003     return 0;
47004   }
47005   {
47006     try {
47007       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
47008     } catch (std::out_of_range& e) {
47009       {
47010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47011       };
47012     } catch (std::exception& e) {
47013       {
47014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47015       };
47016     } catch (Dali::DaliException e) {
47017       {
47018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47019       };
47020     } catch (...) {
47021       {
47022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47023       };
47024     }
47025   }
47026
47027   jresult = result;
47028   return jresult;
47029 }
47030
47031
47032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
47033   unsigned int jresult ;
47034   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47035   Dali::Rect< int > *arg2 = 0 ;
47036   bool result;
47037
47038   arg1 = (Dali::Rect< int > *)jarg1;
47039   arg2 = (Dali::Rect< int > *)jarg2;
47040   if (!arg2) {
47041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47042     return 0;
47043   }
47044   {
47045     try {
47046       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
47047     } catch (std::out_of_range& e) {
47048       {
47049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47050       };
47051     } catch (std::exception& e) {
47052       {
47053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47054       };
47055     } catch (Dali::DaliException e) {
47056       {
47057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47058       };
47059     } catch (...) {
47060       {
47061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47062       };
47063     }
47064   }
47065
47066   jresult = result;
47067   return jresult;
47068 }
47069
47070
47071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47072   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47073   int arg2 ;
47074
47075   arg1 = (Dali::Rect< int > *)jarg1;
47076   arg2 = (int)jarg2;
47077   if (arg1) (arg1)->x = arg2;
47078 }
47079
47080
47081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47082   int jresult ;
47083   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47084   int result;
47085
47086   arg1 = (Dali::Rect< int > *)jarg1;
47087   result = (int) ((arg1)->x);
47088   jresult = result;
47089   return jresult;
47090 }
47091
47092
47093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47094   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47095   int arg2 ;
47096
47097   arg1 = (Dali::Rect< int > *)jarg1;
47098   arg2 = (int)jarg2;
47099   if (arg1) (arg1)->left = arg2;
47100 }
47101
47102
47103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47104   int jresult ;
47105   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47106   int result;
47107
47108   arg1 = (Dali::Rect< int > *)jarg1;
47109   result = (int) ((arg1)->left);
47110   jresult = result;
47111   return jresult;
47112 }
47113
47114
47115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47116   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47117   int arg2 ;
47118
47119   arg1 = (Dali::Rect< int > *)jarg1;
47120   arg2 = (int)jarg2;
47121   if (arg1) (arg1)->y = arg2;
47122 }
47123
47124
47125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47126   int jresult ;
47127   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47128   int result;
47129
47130   arg1 = (Dali::Rect< int > *)jarg1;
47131   result = (int) ((arg1)->y);
47132   jresult = result;
47133   return jresult;
47134 }
47135
47136
47137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47138   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47139   int arg2 ;
47140
47141   arg1 = (Dali::Rect< int > *)jarg1;
47142   arg2 = (int)jarg2;
47143   if (arg1) (arg1)->right = arg2;
47144 }
47145
47146
47147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47148   int jresult ;
47149   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47150   int result;
47151
47152   arg1 = (Dali::Rect< int > *)jarg1;
47153   result = (int) ((arg1)->right);
47154   jresult = result;
47155   return jresult;
47156 }
47157
47158
47159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47160   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47161   int arg2 ;
47162
47163   arg1 = (Dali::Rect< int > *)jarg1;
47164   arg2 = (int)jarg2;
47165   if (arg1) (arg1)->width = arg2;
47166 }
47167
47168
47169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47170   int jresult ;
47171   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47172   int result;
47173
47174   arg1 = (Dali::Rect< int > *)jarg1;
47175   result = (int) ((arg1)->width);
47176   jresult = result;
47177   return jresult;
47178 }
47179
47180
47181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47182   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47183   int arg2 ;
47184
47185   arg1 = (Dali::Rect< int > *)jarg1;
47186   arg2 = (int)jarg2;
47187   if (arg1) (arg1)->bottom = arg2;
47188 }
47189
47190
47191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47192   int jresult ;
47193   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47194   int result;
47195
47196   arg1 = (Dali::Rect< int > *)jarg1;
47197   result = (int) ((arg1)->bottom);
47198   jresult = result;
47199   return jresult;
47200 }
47201
47202
47203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47204   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47205   int arg2 ;
47206
47207   arg1 = (Dali::Rect< int > *)jarg1;
47208   arg2 = (int)jarg2;
47209   if (arg1) (arg1)->height = arg2;
47210 }
47211
47212
47213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47214   int jresult ;
47215   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47216   int result;
47217
47218   arg1 = (Dali::Rect< int > *)jarg1;
47219   result = (int) ((arg1)->height);
47220   jresult = result;
47221   return jresult;
47222 }
47223
47224
47225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47226   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47227   int arg2 ;
47228
47229   arg1 = (Dali::Rect< int > *)jarg1;
47230   arg2 = (int)jarg2;
47231   if (arg1) (arg1)->top = arg2;
47232 }
47233
47234
47235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47236   int jresult ;
47237   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47238   int result;
47239
47240   arg1 = (Dali::Rect< int > *)jarg1;
47241   result = (int) ((arg1)->top);
47242   jresult = result;
47243   return jresult;
47244 }
47245
47246
47247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47248   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47249
47250   arg1 = (Dali::Rect< int > *)jarg1;
47251   {
47252     try {
47253       delete arg1;
47254     } catch (std::out_of_range& e) {
47255       {
47256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47257       };
47258     } catch (std::exception& e) {
47259       {
47260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47261       };
47262     } catch (Dali::DaliException e) {
47263       {
47264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47265       };
47266     } catch (...) {
47267       {
47268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47269       };
47270     }
47271   }
47272
47273 }
47274
47275
47276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47277   void * jresult ;
47278   Dali::Rect< float > *result = 0 ;
47279
47280   {
47281     try {
47282       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47283     } catch (std::out_of_range& e) {
47284       {
47285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47286       };
47287     } catch (std::exception& e) {
47288       {
47289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47290       };
47291     } catch (Dali::DaliException e) {
47292       {
47293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47294       };
47295     } catch (...) {
47296       {
47297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47298       };
47299     }
47300   }
47301
47302   jresult = (void *)result;
47303   return jresult;
47304 }
47305
47306
47307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47308   void * jresult ;
47309   float arg1 ;
47310   float arg2 ;
47311   float arg3 ;
47312   float arg4 ;
47313   Dali::Rect< float > *result = 0 ;
47314
47315   arg1 = (float)jarg1;
47316   arg2 = (float)jarg2;
47317   arg3 = (float)jarg4;
47318   arg4 = (float)jarg3;
47319   {
47320     try {
47321       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47322     } catch (std::out_of_range& e) {
47323       {
47324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47325       };
47326     } catch (std::exception& e) {
47327       {
47328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47329       };
47330     } catch (Dali::DaliException e) {
47331       {
47332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47333       };
47334     } catch (...) {
47335       {
47336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47337       };
47338     }
47339   }
47340
47341   jresult = (void *)result;
47342   return jresult;
47343 }
47344
47345
47346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47347   void * jresult ;
47348   Dali::Rect< float > *arg1 = 0 ;
47349   Dali::Rect< float > *result = 0 ;
47350
47351   arg1 = (Dali::Rect< float > *)jarg1;
47352   if (!arg1) {
47353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47354     return 0;
47355   }
47356   {
47357     try {
47358       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47359     } catch (std::out_of_range& e) {
47360       {
47361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47362       };
47363     } catch (std::exception& e) {
47364       {
47365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47366       };
47367     } catch (Dali::DaliException e) {
47368       {
47369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47370       };
47371     } catch (...) {
47372       {
47373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47374       };
47375     }
47376   }
47377
47378   jresult = (void *)result;
47379   return jresult;
47380 }
47381
47382
47383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47384   void * jresult ;
47385   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47386   Dali::Rect< float > *arg2 = 0 ;
47387   Dali::Rect< float > *result = 0 ;
47388
47389   arg1 = (Dali::Rect< float > *)jarg1;
47390   arg2 = (Dali::Rect< float > *)jarg2;
47391   if (!arg2) {
47392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47393     return 0;
47394   }
47395   {
47396     try {
47397       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47398     } catch (std::out_of_range& e) {
47399       {
47400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47401       };
47402     } catch (std::exception& e) {
47403       {
47404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47405       };
47406     } catch (Dali::DaliException e) {
47407       {
47408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47409       };
47410     } catch (...) {
47411       {
47412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47413       };
47414     }
47415   }
47416
47417   jresult = (void *)result;
47418   return jresult;
47419 }
47420
47421
47422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47423   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47424   float arg2 ;
47425   float arg3 ;
47426   float arg4 ;
47427   float arg5 ;
47428
47429   arg1 = (Dali::Rect< float > *)jarg1;
47430   arg2 = (float)jarg2;
47431   arg3 = (float)jarg3;
47432   arg4 = (float)jarg5;
47433   arg5 = (float)jarg4;
47434   {
47435     try {
47436       (arg1)->Set(arg2,arg3,arg4,arg5);
47437     } catch (std::out_of_range& e) {
47438       {
47439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47440       };
47441     } catch (std::exception& e) {
47442       {
47443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47444       };
47445     } catch (Dali::DaliException e) {
47446       {
47447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47448       };
47449     } catch (...) {
47450       {
47451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47452       };
47453     }
47454   }
47455
47456 }
47457
47458
47459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47460   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47461   float arg2 ;
47462
47463   arg1 = (Dali::Rect< float > *)jarg1;
47464   arg2 = (float)jarg2;
47465   if (arg1) (arg1)->left = arg2;
47466 }
47467
47468
47469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47470   float jresult ;
47471   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47472   float result;
47473
47474   arg1 = (Dali::Rect< float > *)jarg1;
47475   result = (float) ((arg1)->left);
47476   jresult = result;
47477   return jresult;
47478 }
47479
47480
47481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47482   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47483   float arg2 ;
47484
47485   arg1 = (Dali::Rect< float > *)jarg1;
47486   arg2 = (float)jarg2;
47487   if (arg1) (arg1)->left = arg2;
47488 }
47489
47490
47491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47492   float jresult ;
47493   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47494   float result;
47495
47496   arg1 = (Dali::Rect< float > *)jarg1;
47497   result = (float) ((arg1)->left);
47498   jresult = result;
47499   return jresult;
47500 }
47501
47502
47503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47504   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47505   float arg2 ;
47506
47507   arg1 = (Dali::Rect< float > *)jarg1;
47508   arg2 = (float)jarg2;
47509   if (arg1) (arg1)->right = arg2;
47510 }
47511
47512
47513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47514   float jresult ;
47515   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47516   float result;
47517
47518   arg1 = (Dali::Rect< float > *)jarg1;
47519   result = (float) ((arg1)->right);
47520   jresult = result;
47521   return jresult;
47522 }
47523
47524
47525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47526   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47527   float arg2 ;
47528
47529   arg1 = (Dali::Rect< float > *)jarg1;
47530   arg2 = (float)jarg2;
47531   if (arg1) (arg1)->right = arg2;
47532 }
47533
47534
47535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47536   float jresult ;
47537   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47538   float result;
47539
47540   arg1 = (Dali::Rect< float > *)jarg1;
47541   result = (float) ((arg1)->right);
47542   jresult = result;
47543   return jresult;
47544 }
47545
47546
47547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
47548   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47549   float arg2 ;
47550
47551   arg1 = (Dali::Rect< float > *)jarg1;
47552   arg2 = (float)jarg2;
47553   if (arg1) (arg1)->bottom = arg2;
47554 }
47555
47556
47557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
47558   float jresult ;
47559   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47560   float result;
47561
47562   arg1 = (Dali::Rect< float > *)jarg1;
47563   result = (float) ((arg1)->bottom);
47564   jresult = result;
47565   return jresult;
47566 }
47567
47568
47569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
47570   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47571   float arg2 ;
47572
47573   arg1 = (Dali::Rect< float > *)jarg1;
47574   arg2 = (float)jarg2;
47575   if (arg1) (arg1)->top = arg2;
47576 }
47577
47578
47579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
47580   float jresult ;
47581   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47582   float result;
47583
47584   arg1 = (Dali::Rect< float > *)jarg1;
47585   result = (float) ((arg1)->top);
47586   jresult = result;
47587   return jresult;
47588 }
47589
47590
47591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
47592   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47593
47594   arg1 = (Dali::Rect< float > *)jarg1;
47595   {
47596     try {
47597       delete arg1;
47598     } catch (std::out_of_range& e) {
47599       {
47600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47601       };
47602     } catch (std::exception& e) {
47603       {
47604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47605       };
47606     } catch (Dali::DaliException e) {
47607       {
47608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47609       };
47610     } catch (...) {
47611       {
47612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47613       };
47614     }
47615   }
47616
47617 }
47618
47619
47620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
47621   int jresult ;
47622   int result;
47623
47624   result = (int)Dali::Vector< int >::BaseType;
47625   jresult = (int)result;
47626   return jresult;
47627 }
47628
47629
47630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
47631   void * jresult ;
47632   Dali::Vector< int > *result = 0 ;
47633
47634   {
47635     try {
47636       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47637     } catch (std::out_of_range& e) {
47638       {
47639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47640       };
47641     } catch (std::exception& e) {
47642       {
47643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47644       };
47645     } catch (Dali::DaliException e) {
47646       {
47647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47648       };
47649     } catch (...) {
47650       {
47651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47652       };
47653     }
47654   }
47655
47656   jresult = (void *)result;
47657   return jresult;
47658 }
47659
47660
47661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
47662   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47663
47664   arg1 = (Dali::Vector< int > *)jarg1;
47665   {
47666     try {
47667       delete arg1;
47668     } catch (std::out_of_range& e) {
47669       {
47670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47671       };
47672     } catch (std::exception& e) {
47673       {
47674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47675       };
47676     } catch (Dali::DaliException e) {
47677       {
47678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47679       };
47680     } catch (...) {
47681       {
47682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47683       };
47684     }
47685   }
47686
47687 }
47688
47689
47690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
47691   void * jresult ;
47692   Dali::Vector< int > *arg1 = 0 ;
47693   Dali::Vector< int > *result = 0 ;
47694
47695   arg1 = (Dali::Vector< int > *)jarg1;
47696   if (!arg1) {
47697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47698     return 0;
47699   }
47700   {
47701     try {
47702       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47703     } catch (std::out_of_range& e) {
47704       {
47705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47706       };
47707     } catch (std::exception& e) {
47708       {
47709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47710       };
47711     } catch (Dali::DaliException e) {
47712       {
47713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47714       };
47715     } catch (...) {
47716       {
47717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47718       };
47719     }
47720   }
47721
47722   jresult = (void *)result;
47723   return jresult;
47724 }
47725
47726
47727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
47728   void * jresult ;
47729   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47730   Dali::Vector< int > *arg2 = 0 ;
47731   Dali::Vector< int > *result = 0 ;
47732
47733   arg1 = (Dali::Vector< int > *)jarg1;
47734   arg2 = (Dali::Vector< int > *)jarg2;
47735   if (!arg2) {
47736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47737     return 0;
47738   }
47739   {
47740     try {
47741       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
47742     } catch (std::out_of_range& e) {
47743       {
47744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47745       };
47746     } catch (std::exception& e) {
47747       {
47748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47749       };
47750     } catch (Dali::DaliException e) {
47751       {
47752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47753       };
47754     } catch (...) {
47755       {
47756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47757       };
47758     }
47759   }
47760
47761   jresult = (void *)result;
47762   return jresult;
47763 }
47764
47765
47766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
47767   void * jresult ;
47768   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47769   Dali::Vector< int >::Iterator result;
47770
47771   arg1 = (Dali::Vector< int > *)jarg1;
47772   {
47773     try {
47774       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
47775     } catch (std::out_of_range& e) {
47776       {
47777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47778       };
47779     } catch (std::exception& e) {
47780       {
47781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47782       };
47783     } catch (Dali::DaliException e) {
47784       {
47785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47786       };
47787     } catch (...) {
47788       {
47789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47790       };
47791     }
47792   }
47793
47794   jresult = (void *)result;
47795   return jresult;
47796 }
47797
47798
47799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
47800   void * jresult ;
47801   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47802   Dali::Vector< int >::Iterator result;
47803
47804   arg1 = (Dali::Vector< int > *)jarg1;
47805   {
47806     try {
47807       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
47808     } catch (std::out_of_range& e) {
47809       {
47810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47811       };
47812     } catch (std::exception& e) {
47813       {
47814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47815       };
47816     } catch (Dali::DaliException e) {
47817       {
47818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47819       };
47820     } catch (...) {
47821       {
47822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47823       };
47824     }
47825   }
47826
47827   jresult = (void *)result;
47828   return jresult;
47829 }
47830
47831
47832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47833   void * jresult ;
47834   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47835   Dali::Vector< int >::SizeType arg2 ;
47836   Dali::Vector< int >::ItemType *result = 0 ;
47837
47838   arg1 = (Dali::Vector< int > *)jarg1;
47839   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47840   {
47841     try {
47842       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
47843     } catch (std::out_of_range& e) {
47844       {
47845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47846       };
47847     } catch (std::exception& e) {
47848       {
47849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47850       };
47851     } catch (Dali::DaliException e) {
47852       {
47853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47854       };
47855     } catch (...) {
47856       {
47857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47858       };
47859     }
47860   }
47861
47862   jresult = (void *)result;
47863   return jresult;
47864 }
47865
47866
47867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
47868   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47869   Dali::Vector< int >::ItemType *arg2 = 0 ;
47870   Dali::Vector< int >::ItemType temp2 ;
47871
47872   arg1 = (Dali::Vector< int > *)jarg1;
47873   temp2 = (Dali::Vector< int >::ItemType)jarg2;
47874   arg2 = &temp2;
47875   {
47876     try {
47877       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
47878     } catch (std::out_of_range& e) {
47879       {
47880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47881       };
47882     } catch (std::exception& e) {
47883       {
47884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47885       };
47886     } catch (Dali::DaliException e) {
47887       {
47888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47889       };
47890     } catch (...) {
47891       {
47892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47893       };
47894     }
47895   }
47896
47897 }
47898
47899
47900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
47901   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47902   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47903   Dali::Vector< int >::ItemType *arg3 = 0 ;
47904   Dali::Vector< int >::ItemType temp3 ;
47905
47906   arg1 = (Dali::Vector< int > *)jarg1;
47907   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47908   temp3 = (Dali::Vector< int >::ItemType)jarg3;
47909   arg3 = &temp3;
47910   {
47911     try {
47912       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
47913     } catch (std::out_of_range& e) {
47914       {
47915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47916       };
47917     } catch (std::exception& e) {
47918       {
47919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47920       };
47921     } catch (Dali::DaliException e) {
47922       {
47923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47924       };
47925     } catch (...) {
47926       {
47927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47928       };
47929     }
47930   }
47931
47932 }
47933
47934
47935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47936   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47937   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47938   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
47939   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
47940
47941   arg1 = (Dali::Vector< int > *)jarg1;
47942   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47943   arg3 = (Dali::Vector< int >::Iterator)jarg3;
47944   arg4 = (Dali::Vector< int >::Iterator)jarg4;
47945   {
47946     try {
47947       (arg1)->Insert(arg2,arg3,arg4);
47948     } catch (std::out_of_range& e) {
47949       {
47950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47951       };
47952     } catch (std::exception& e) {
47953       {
47954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47955       };
47956     } catch (Dali::DaliException e) {
47957       {
47958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47959       };
47960     } catch (...) {
47961       {
47962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47963       };
47964     }
47965   }
47966
47967 }
47968
47969
47970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
47971   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47972   Dali::Vector< int >::SizeType arg2 ;
47973
47974   arg1 = (Dali::Vector< int > *)jarg1;
47975   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47976   {
47977     try {
47978       (arg1)->Reserve(arg2);
47979     } catch (std::out_of_range& e) {
47980       {
47981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47982       };
47983     } catch (std::exception& e) {
47984       {
47985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47986       };
47987     } catch (Dali::DaliException e) {
47988       {
47989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47990       };
47991     } catch (...) {
47992       {
47993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47994       };
47995     }
47996   }
47997
47998 }
47999
48000
48001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48002   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48003   Dali::Vector< int >::SizeType arg2 ;
48004
48005   arg1 = (Dali::Vector< int > *)jarg1;
48006   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48007   {
48008     try {
48009       (arg1)->Resize(arg2);
48010     } catch (std::out_of_range& e) {
48011       {
48012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48013       };
48014     } catch (std::exception& e) {
48015       {
48016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48017       };
48018     } catch (Dali::DaliException e) {
48019       {
48020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48021       };
48022     } catch (...) {
48023       {
48024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48025       };
48026     }
48027   }
48028
48029 }
48030
48031
48032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
48033   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48034   Dali::Vector< int >::SizeType arg2 ;
48035   Dali::Vector< int >::ItemType *arg3 = 0 ;
48036   Dali::Vector< int >::ItemType temp3 ;
48037
48038   arg1 = (Dali::Vector< int > *)jarg1;
48039   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48040   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48041   arg3 = &temp3;
48042   {
48043     try {
48044       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48045     } catch (std::out_of_range& e) {
48046       {
48047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48048       };
48049     } catch (std::exception& e) {
48050       {
48051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48052       };
48053     } catch (Dali::DaliException e) {
48054       {
48055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48056       };
48057     } catch (...) {
48058       {
48059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48060       };
48061     }
48062   }
48063
48064 }
48065
48066
48067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48068   void * jresult ;
48069   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48070   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48071   Dali::Vector< int >::Iterator result;
48072
48073   arg1 = (Dali::Vector< int > *)jarg1;
48074   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48075   {
48076     try {
48077       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48078     } catch (std::out_of_range& e) {
48079       {
48080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48081       };
48082     } catch (std::exception& e) {
48083       {
48084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48085       };
48086     } catch (Dali::DaliException e) {
48087       {
48088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48089       };
48090     } catch (...) {
48091       {
48092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48093       };
48094     }
48095   }
48096
48097   jresult = (void *)result;
48098   return jresult;
48099 }
48100
48101
48102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48103   void * jresult ;
48104   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48105   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48106   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48107   Dali::Vector< int >::Iterator result;
48108
48109   arg1 = (Dali::Vector< int > *)jarg1;
48110   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48111   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48112   {
48113     try {
48114       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48115     } catch (std::out_of_range& e) {
48116       {
48117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48118       };
48119     } catch (std::exception& e) {
48120       {
48121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48122       };
48123     } catch (Dali::DaliException e) {
48124       {
48125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48126       };
48127     } catch (...) {
48128       {
48129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48130       };
48131     }
48132   }
48133
48134   jresult = (void *)result;
48135   return jresult;
48136 }
48137
48138
48139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48140   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48141   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48142
48143   arg1 = (Dali::Vector< int > *)jarg1;
48144   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48145   {
48146     try {
48147       (arg1)->Remove(arg2);
48148     } catch (std::out_of_range& e) {
48149       {
48150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48151       };
48152     } catch (std::exception& e) {
48153       {
48154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48155       };
48156     } catch (Dali::DaliException e) {
48157       {
48158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48159       };
48160     } catch (...) {
48161       {
48162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48163       };
48164     }
48165   }
48166
48167 }
48168
48169
48170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48171   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48172   Dali::Vector< int > *arg2 = 0 ;
48173
48174   arg1 = (Dali::Vector< int > *)jarg1;
48175   arg2 = (Dali::Vector< int > *)jarg2;
48176   if (!arg2) {
48177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48178     return ;
48179   }
48180   {
48181     try {
48182       (arg1)->Swap(*arg2);
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 void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48206   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48207
48208   arg1 = (Dali::Vector< int > *)jarg1;
48209   {
48210     try {
48211       (arg1)->Clear();
48212     } catch (std::out_of_range& e) {
48213       {
48214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48215       };
48216     } catch (std::exception& e) {
48217       {
48218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48219       };
48220     } catch (Dali::DaliException e) {
48221       {
48222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48223       };
48224     } catch (...) {
48225       {
48226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48227       };
48228     }
48229   }
48230
48231 }
48232
48233
48234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48235   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48236
48237   arg1 = (Dali::Vector< int > *)jarg1;
48238   {
48239     try {
48240       (arg1)->Release();
48241     } catch (std::out_of_range& e) {
48242       {
48243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48244       };
48245     } catch (std::exception& e) {
48246       {
48247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48248       };
48249     } catch (Dali::DaliException e) {
48250       {
48251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48252       };
48253     } catch (...) {
48254       {
48255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48256       };
48257     }
48258   }
48259
48260 }
48261
48262
48263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48264   int jresult ;
48265   int result;
48266
48267   result = (int)Dali::Vector< float >::BaseType;
48268   jresult = (int)result;
48269   return jresult;
48270 }
48271
48272
48273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48274   void * jresult ;
48275   Dali::Vector< float > *result = 0 ;
48276
48277   {
48278     try {
48279       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48280     } catch (std::out_of_range& e) {
48281       {
48282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48283       };
48284     } catch (std::exception& e) {
48285       {
48286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48287       };
48288     } catch (Dali::DaliException e) {
48289       {
48290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48291       };
48292     } catch (...) {
48293       {
48294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48295       };
48296     }
48297   }
48298
48299   jresult = (void *)result;
48300   return jresult;
48301 }
48302
48303
48304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48305   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48306
48307   arg1 = (Dali::Vector< float > *)jarg1;
48308   {
48309     try {
48310       delete arg1;
48311     } catch (std::out_of_range& e) {
48312       {
48313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48314       };
48315     } catch (std::exception& e) {
48316       {
48317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48318       };
48319     } catch (Dali::DaliException e) {
48320       {
48321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48322       };
48323     } catch (...) {
48324       {
48325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48326       };
48327     }
48328   }
48329
48330 }
48331
48332
48333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48334   void * jresult ;
48335   Dali::Vector< float > *arg1 = 0 ;
48336   Dali::Vector< float > *result = 0 ;
48337
48338   arg1 = (Dali::Vector< float > *)jarg1;
48339   if (!arg1) {
48340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48341     return 0;
48342   }
48343   {
48344     try {
48345       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48346     } catch (std::out_of_range& e) {
48347       {
48348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48349       };
48350     } catch (std::exception& e) {
48351       {
48352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48353       };
48354     } catch (Dali::DaliException e) {
48355       {
48356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48357       };
48358     } catch (...) {
48359       {
48360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48361       };
48362     }
48363   }
48364
48365   jresult = (void *)result;
48366   return jresult;
48367 }
48368
48369
48370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48371   void * jresult ;
48372   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48373   Dali::Vector< float > *arg2 = 0 ;
48374   Dali::Vector< float > *result = 0 ;
48375
48376   arg1 = (Dali::Vector< float > *)jarg1;
48377   arg2 = (Dali::Vector< float > *)jarg2;
48378   if (!arg2) {
48379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48380     return 0;
48381   }
48382   {
48383     try {
48384       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48385     } catch (std::out_of_range& e) {
48386       {
48387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48388       };
48389     } catch (std::exception& e) {
48390       {
48391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48392       };
48393     } catch (Dali::DaliException e) {
48394       {
48395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48396       };
48397     } catch (...) {
48398       {
48399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48400       };
48401     }
48402   }
48403
48404   jresult = (void *)result;
48405   return jresult;
48406 }
48407
48408
48409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48410   void * jresult ;
48411   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48412   Dali::Vector< float >::Iterator result;
48413
48414   arg1 = (Dali::Vector< float > *)jarg1;
48415   {
48416     try {
48417       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48418     } catch (std::out_of_range& e) {
48419       {
48420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48421       };
48422     } catch (std::exception& e) {
48423       {
48424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48425       };
48426     } catch (Dali::DaliException e) {
48427       {
48428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48429       };
48430     } catch (...) {
48431       {
48432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48433       };
48434     }
48435   }
48436
48437   jresult = (void *)result;
48438   return jresult;
48439 }
48440
48441
48442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48443   void * jresult ;
48444   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48445   Dali::Vector< float >::Iterator result;
48446
48447   arg1 = (Dali::Vector< float > *)jarg1;
48448   {
48449     try {
48450       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48451     } catch (std::out_of_range& e) {
48452       {
48453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48454       };
48455     } catch (std::exception& e) {
48456       {
48457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48458       };
48459     } catch (Dali::DaliException e) {
48460       {
48461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48462       };
48463     } catch (...) {
48464       {
48465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48466       };
48467     }
48468   }
48469
48470   jresult = (void *)result;
48471   return jresult;
48472 }
48473
48474
48475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48476   void * jresult ;
48477   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48478   Dali::Vector< float >::SizeType arg2 ;
48479   Dali::Vector< float >::ItemType *result = 0 ;
48480
48481   arg1 = (Dali::Vector< float > *)jarg1;
48482   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48483   {
48484     try {
48485       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48486     } catch (std::out_of_range& e) {
48487       {
48488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48489       };
48490     } catch (std::exception& e) {
48491       {
48492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48493       };
48494     } catch (Dali::DaliException e) {
48495       {
48496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48497       };
48498     } catch (...) {
48499       {
48500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48501       };
48502     }
48503   }
48504
48505   jresult = (void *)result;
48506   return jresult;
48507 }
48508
48509
48510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48511   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48512   Dali::Vector< float >::ItemType *arg2 = 0 ;
48513   Dali::Vector< float >::ItemType temp2 ;
48514
48515   arg1 = (Dali::Vector< float > *)jarg1;
48516   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48517   arg2 = &temp2;
48518   {
48519     try {
48520       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48521     } catch (std::out_of_range& e) {
48522       {
48523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48524       };
48525     } catch (std::exception& e) {
48526       {
48527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48528       };
48529     } catch (Dali::DaliException e) {
48530       {
48531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48532       };
48533     } catch (...) {
48534       {
48535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48536       };
48537     }
48538   }
48539
48540 }
48541
48542
48543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48544   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48545   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48546   Dali::Vector< float >::ItemType *arg3 = 0 ;
48547   Dali::Vector< float >::ItemType temp3 ;
48548
48549   arg1 = (Dali::Vector< float > *)jarg1;
48550   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48551   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48552   arg3 = &temp3;
48553   {
48554     try {
48555       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48556     } catch (std::out_of_range& e) {
48557       {
48558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48559       };
48560     } catch (std::exception& e) {
48561       {
48562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48563       };
48564     } catch (Dali::DaliException e) {
48565       {
48566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48567       };
48568     } catch (...) {
48569       {
48570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48571       };
48572     }
48573   }
48574
48575 }
48576
48577
48578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48579   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48580   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48581   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48582   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
48583
48584   arg1 = (Dali::Vector< float > *)jarg1;
48585   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48586   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48587   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48588   {
48589     try {
48590       (arg1)->Insert(arg2,arg3,arg4);
48591     } catch (std::out_of_range& e) {
48592       {
48593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48594       };
48595     } catch (std::exception& e) {
48596       {
48597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48598       };
48599     } catch (Dali::DaliException e) {
48600       {
48601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48602       };
48603     } catch (...) {
48604       {
48605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48606       };
48607     }
48608   }
48609
48610 }
48611
48612
48613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48614   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48615   Dali::Vector< float >::SizeType arg2 ;
48616
48617   arg1 = (Dali::Vector< float > *)jarg1;
48618   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48619   {
48620     try {
48621       (arg1)->Reserve(arg2);
48622     } catch (std::out_of_range& e) {
48623       {
48624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48625       };
48626     } catch (std::exception& e) {
48627       {
48628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48629       };
48630     } catch (Dali::DaliException e) {
48631       {
48632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48633       };
48634     } catch (...) {
48635       {
48636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48637       };
48638     }
48639   }
48640
48641 }
48642
48643 //// ========================= end of part 2 =============================
48644
48645 //// ========================== start part 3 ===============================
48646
48647
48648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48649   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48650   Dali::Vector< float >::SizeType arg2 ;
48651
48652   arg1 = (Dali::Vector< float > *)jarg1;
48653   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48654   {
48655     try {
48656       (arg1)->Resize(arg2);
48657     } catch (std::out_of_range& e) {
48658       {
48659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48660       };
48661     } catch (std::exception& e) {
48662       {
48663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48664       };
48665     } catch (Dali::DaliException e) {
48666       {
48667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48668       };
48669     } catch (...) {
48670       {
48671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48672       };
48673     }
48674   }
48675
48676 }
48677
48678
48679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48680   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48681   Dali::Vector< float >::SizeType arg2 ;
48682   Dali::Vector< float >::ItemType *arg3 = 0 ;
48683   Dali::Vector< float >::ItemType temp3 ;
48684
48685   arg1 = (Dali::Vector< float > *)jarg1;
48686   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48687   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48688   arg3 = &temp3;
48689   {
48690     try {
48691       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48692     } catch (std::out_of_range& e) {
48693       {
48694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48695       };
48696     } catch (std::exception& e) {
48697       {
48698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48699       };
48700     } catch (Dali::DaliException e) {
48701       {
48702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48703       };
48704     } catch (...) {
48705       {
48706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48707       };
48708     }
48709   }
48710
48711 }
48712
48713
48714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48715   void * jresult ;
48716   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48717   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48718   Dali::Vector< float >::Iterator result;
48719
48720   arg1 = (Dali::Vector< float > *)jarg1;
48721   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48722   {
48723     try {
48724       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48725     } catch (std::out_of_range& e) {
48726       {
48727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48728       };
48729     } catch (std::exception& e) {
48730       {
48731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48732       };
48733     } catch (Dali::DaliException e) {
48734       {
48735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48736       };
48737     } catch (...) {
48738       {
48739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48740       };
48741     }
48742   }
48743
48744   jresult = (void *)result;
48745   return jresult;
48746 }
48747
48748
48749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48750   void * jresult ;
48751   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48752   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48753   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48754   Dali::Vector< float >::Iterator result;
48755
48756   arg1 = (Dali::Vector< float > *)jarg1;
48757   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48758   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48759   {
48760     try {
48761       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
48762     } catch (std::out_of_range& e) {
48763       {
48764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48765       };
48766     } catch (std::exception& e) {
48767       {
48768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48769       };
48770     } catch (Dali::DaliException e) {
48771       {
48772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48773       };
48774     } catch (...) {
48775       {
48776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48777       };
48778     }
48779   }
48780
48781   jresult = (void *)result;
48782   return jresult;
48783 }
48784
48785
48786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
48787   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48788   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48789
48790   arg1 = (Dali::Vector< float > *)jarg1;
48791   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48792   {
48793     try {
48794       (arg1)->Remove(arg2);
48795     } catch (std::out_of_range& e) {
48796       {
48797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48798       };
48799     } catch (std::exception& e) {
48800       {
48801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48802       };
48803     } catch (Dali::DaliException e) {
48804       {
48805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48806       };
48807     } catch (...) {
48808       {
48809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48810       };
48811     }
48812   }
48813
48814 }
48815
48816
48817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
48818   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48819   Dali::Vector< float > *arg2 = 0 ;
48820
48821   arg1 = (Dali::Vector< float > *)jarg1;
48822   arg2 = (Dali::Vector< float > *)jarg2;
48823   if (!arg2) {
48824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
48825     return ;
48826   }
48827   {
48828     try {
48829       (arg1)->Swap(*arg2);
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 void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
48853   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48854
48855   arg1 = (Dali::Vector< float > *)jarg1;
48856   {
48857     try {
48858       (arg1)->Clear();
48859     } catch (std::out_of_range& e) {
48860       {
48861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48862       };
48863     } catch (std::exception& e) {
48864       {
48865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48866       };
48867     } catch (Dali::DaliException e) {
48868       {
48869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48870       };
48871     } catch (...) {
48872       {
48873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48874       };
48875     }
48876   }
48877
48878 }
48879
48880
48881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
48882   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48883
48884   arg1 = (Dali::Vector< float > *)jarg1;
48885   {
48886     try {
48887       (arg1)->Release();
48888     } catch (std::out_of_range& e) {
48889       {
48890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48891       };
48892     } catch (std::exception& e) {
48893       {
48894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48895       };
48896     } catch (Dali::DaliException e) {
48897       {
48898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48899       };
48900     } catch (...) {
48901       {
48902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48903       };
48904     }
48905   }
48906
48907 }
48908
48909
48910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
48911   int jresult ;
48912   int result;
48913
48914   result = (int)Dali::Vector< unsigned char >::BaseType;
48915   jresult = (int)result;
48916   return jresult;
48917 }
48918
48919
48920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
48921   void * jresult ;
48922   Dali::Vector< unsigned char > *result = 0 ;
48923
48924   {
48925     try {
48926       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
48927     } catch (std::out_of_range& e) {
48928       {
48929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48930       };
48931     } catch (std::exception& e) {
48932       {
48933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48934       };
48935     } catch (Dali::DaliException e) {
48936       {
48937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48938       };
48939     } catch (...) {
48940       {
48941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48942       };
48943     }
48944   }
48945
48946   jresult = (void *)result;
48947   return jresult;
48948 }
48949
48950
48951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
48952   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48953
48954   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48955   {
48956     try {
48957       delete arg1;
48958     } catch (std::out_of_range& e) {
48959       {
48960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48961       };
48962     } catch (std::exception& e) {
48963       {
48964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48965       };
48966     } catch (Dali::DaliException e) {
48967       {
48968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48969       };
48970     } catch (...) {
48971       {
48972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48973       };
48974     }
48975   }
48976
48977 }
48978
48979
48980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
48981   void * jresult ;
48982   Dali::Vector< unsigned char > *arg1 = 0 ;
48983   Dali::Vector< unsigned char > *result = 0 ;
48984
48985   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48986   if (!arg1) {
48987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48988     return 0;
48989   }
48990   {
48991     try {
48992       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
48993     } catch (std::out_of_range& e) {
48994       {
48995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48996       };
48997     } catch (std::exception& e) {
48998       {
48999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49000       };
49001     } catch (Dali::DaliException e) {
49002       {
49003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49004       };
49005     } catch (...) {
49006       {
49007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49008       };
49009     }
49010   }
49011
49012   jresult = (void *)result;
49013   return jresult;
49014 }
49015
49016
49017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
49018   void * jresult ;
49019   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49020   Dali::Vector< unsigned char > *arg2 = 0 ;
49021   Dali::Vector< unsigned char > *result = 0 ;
49022
49023   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49024   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49025   if (!arg2) {
49026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49027     return 0;
49028   }
49029   {
49030     try {
49031       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
49032     } catch (std::out_of_range& e) {
49033       {
49034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49035       };
49036     } catch (std::exception& e) {
49037       {
49038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49039       };
49040     } catch (Dali::DaliException e) {
49041       {
49042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49043       };
49044     } catch (...) {
49045       {
49046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49047       };
49048     }
49049   }
49050
49051   jresult = (void *)result;
49052   return jresult;
49053 }
49054
49055
49056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
49057   void * jresult ;
49058   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49059   Dali::Vector< unsigned char >::Iterator result;
49060
49061   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49062   {
49063     try {
49064       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49065     } catch (std::out_of_range& e) {
49066       {
49067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49068       };
49069     } catch (std::exception& e) {
49070       {
49071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49072       };
49073     } catch (Dali::DaliException e) {
49074       {
49075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49076       };
49077     } catch (...) {
49078       {
49079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49080       };
49081     }
49082   }
49083
49084   jresult = (void *)result;
49085   return jresult;
49086 }
49087
49088
49089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49090   void * jresult ;
49091   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49092   Dali::Vector< unsigned char >::Iterator result;
49093
49094   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49095   {
49096     try {
49097       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49098     } catch (std::out_of_range& e) {
49099       {
49100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49101       };
49102     } catch (std::exception& e) {
49103       {
49104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49105       };
49106     } catch (Dali::DaliException e) {
49107       {
49108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49109       };
49110     } catch (...) {
49111       {
49112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49113       };
49114     }
49115   }
49116
49117   jresult = (void *)result;
49118   return jresult;
49119 }
49120
49121
49122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49123   void * jresult ;
49124   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49125   Dali::Vector< unsigned char >::SizeType arg2 ;
49126   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49127
49128   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49129   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49130   {
49131     try {
49132       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49133     } catch (std::out_of_range& e) {
49134       {
49135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49136       };
49137     } catch (std::exception& e) {
49138       {
49139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49140       };
49141     } catch (Dali::DaliException e) {
49142       {
49143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49144       };
49145     } catch (...) {
49146       {
49147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49148       };
49149     }
49150   }
49151
49152   jresult = (void *)result;
49153   return jresult;
49154 }
49155
49156
49157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49158   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49159   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49160   Dali::Vector< unsigned char >::ItemType temp2 ;
49161
49162   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49163   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49164   arg2 = &temp2;
49165   {
49166     try {
49167       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49168     } catch (std::out_of_range& e) {
49169       {
49170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49171       };
49172     } catch (std::exception& e) {
49173       {
49174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49175       };
49176     } catch (Dali::DaliException e) {
49177       {
49178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49179       };
49180     } catch (...) {
49181       {
49182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49183       };
49184     }
49185   }
49186
49187 }
49188
49189
49190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49191   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49192   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49193   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49194   Dali::Vector< unsigned char >::ItemType temp3 ;
49195
49196   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49197   arg2 = jarg2;
49198   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49199   arg3 = &temp3;
49200   {
49201     try {
49202       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49203     } catch (std::out_of_range& e) {
49204       {
49205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49206       };
49207     } catch (std::exception& e) {
49208       {
49209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49210       };
49211     } catch (Dali::DaliException e) {
49212       {
49213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49214       };
49215     } catch (...) {
49216       {
49217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49218       };
49219     }
49220   }
49221
49222
49223
49224 }
49225
49226
49227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49228   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49229   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49230   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49231   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49232
49233   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49234   arg2 = jarg2;
49235   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49236   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49237   {
49238     try {
49239       (arg1)->Insert(arg2,arg3,arg4);
49240     } catch (std::out_of_range& e) {
49241       {
49242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49243       };
49244     } catch (std::exception& e) {
49245       {
49246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49247       };
49248     } catch (Dali::DaliException e) {
49249       {
49250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49251       };
49252     } catch (...) {
49253       {
49254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49255       };
49256     }
49257   }
49258
49259
49260
49261 }
49262
49263
49264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49265   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49266   Dali::Vector< unsigned char >::SizeType arg2 ;
49267
49268   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49269   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49270   {
49271     try {
49272       (arg1)->Reserve(arg2);
49273     } catch (std::out_of_range& e) {
49274       {
49275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49276       };
49277     } catch (std::exception& e) {
49278       {
49279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49280       };
49281     } catch (Dali::DaliException e) {
49282       {
49283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49284       };
49285     } catch (...) {
49286       {
49287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49288       };
49289     }
49290   }
49291
49292 }
49293
49294
49295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49296   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49297   Dali::Vector< unsigned char >::SizeType arg2 ;
49298
49299   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49300   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49301   {
49302     try {
49303       (arg1)->Resize(arg2);
49304     } catch (std::out_of_range& e) {
49305       {
49306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49307       };
49308     } catch (std::exception& e) {
49309       {
49310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49311       };
49312     } catch (Dali::DaliException e) {
49313       {
49314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49315       };
49316     } catch (...) {
49317       {
49318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49319       };
49320     }
49321   }
49322
49323 }
49324
49325
49326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49327   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49328   Dali::Vector< unsigned char >::SizeType arg2 ;
49329   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49330   Dali::Vector< unsigned char >::ItemType temp3 ;
49331
49332   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49333   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49334   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49335   arg3 = &temp3;
49336   {
49337     try {
49338       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49339     } catch (std::out_of_range& e) {
49340       {
49341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49342       };
49343     } catch (std::exception& e) {
49344       {
49345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49346       };
49347     } catch (Dali::DaliException e) {
49348       {
49349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49350       };
49351     } catch (...) {
49352       {
49353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49354       };
49355     }
49356   }
49357
49358 }
49359
49360
49361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49362   void * jresult ;
49363   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49364   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49365   Dali::Vector< unsigned char >::Iterator result;
49366
49367   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49368   arg2 = jarg2;
49369   {
49370     try {
49371       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49372     } catch (std::out_of_range& e) {
49373       {
49374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49375       };
49376     } catch (std::exception& e) {
49377       {
49378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49379       };
49380     } catch (Dali::DaliException e) {
49381       {
49382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49383       };
49384     } catch (...) {
49385       {
49386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49387       };
49388     }
49389   }
49390
49391   jresult = (void *)result;
49392
49393
49394   return jresult;
49395 }
49396
49397
49398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49399   void * jresult ;
49400   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49401   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49402   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49403   Dali::Vector< unsigned char >::Iterator result;
49404
49405   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49406   arg2 = jarg2;
49407   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49408   {
49409     try {
49410       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49411     } catch (std::out_of_range& e) {
49412       {
49413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49414       };
49415     } catch (std::exception& e) {
49416       {
49417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49418       };
49419     } catch (Dali::DaliException e) {
49420       {
49421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49422       };
49423     } catch (...) {
49424       {
49425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49426       };
49427     }
49428   }
49429
49430   jresult = (void *)result;
49431
49432
49433   return jresult;
49434 }
49435
49436
49437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49438   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49439   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49440
49441   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49442   arg2 = jarg2;
49443   {
49444     try {
49445       (arg1)->Remove(arg2);
49446     } catch (std::out_of_range& e) {
49447       {
49448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49449       };
49450     } catch (std::exception& e) {
49451       {
49452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49453       };
49454     } catch (Dali::DaliException e) {
49455       {
49456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49457       };
49458     } catch (...) {
49459       {
49460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49461       };
49462     }
49463   }
49464
49465
49466
49467 }
49468
49469
49470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49471   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49472   Dali::Vector< unsigned char > *arg2 = 0 ;
49473
49474   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49475   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49476   if (!arg2) {
49477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49478     return ;
49479   }
49480   {
49481     try {
49482       (arg1)->Swap(*arg2);
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 void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49506   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49507
49508   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49509   {
49510     try {
49511       (arg1)->Clear();
49512     } catch (std::out_of_range& e) {
49513       {
49514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49515       };
49516     } catch (std::exception& e) {
49517       {
49518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49519       };
49520     } catch (Dali::DaliException e) {
49521       {
49522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49523       };
49524     } catch (...) {
49525       {
49526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49527       };
49528     }
49529   }
49530
49531 }
49532
49533
49534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49535   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49536
49537   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49538   {
49539     try {
49540       (arg1)->Release();
49541     } catch (std::out_of_range& e) {
49542       {
49543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49544       };
49545     } catch (std::exception& e) {
49546       {
49547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49548       };
49549     } catch (Dali::DaliException e) {
49550       {
49551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49552       };
49553     } catch (...) {
49554       {
49555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49556       };
49557     }
49558   }
49559
49560 }
49561
49562
49563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
49564   int jresult ;
49565   int result;
49566
49567   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49568   jresult = (int)result;
49569   return jresult;
49570 }
49571
49572
49573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
49574   void * jresult ;
49575   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49576
49577   {
49578     try {
49579       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49580     } catch (std::out_of_range& e) {
49581       {
49582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49583       };
49584     } catch (std::exception& e) {
49585       {
49586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49587       };
49588     } catch (Dali::DaliException e) {
49589       {
49590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49591       };
49592     } catch (...) {
49593       {
49594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49595       };
49596     }
49597   }
49598
49599   jresult = (void *)result;
49600   return jresult;
49601 }
49602
49603
49604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
49605   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49606
49607   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49608   {
49609     try {
49610       delete arg1;
49611     } catch (std::out_of_range& e) {
49612       {
49613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49614       };
49615     } catch (std::exception& e) {
49616       {
49617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49618       };
49619     } catch (Dali::DaliException e) {
49620       {
49621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49622       };
49623     } catch (...) {
49624       {
49625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49626       };
49627     }
49628   }
49629
49630 }
49631
49632
49633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49634   void * jresult ;
49635   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49636   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49637
49638   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49639   if (!arg1) {
49640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49641     return 0;
49642   }
49643   {
49644     try {
49645       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49646     } catch (std::out_of_range& e) {
49647       {
49648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49649       };
49650     } catch (std::exception& e) {
49651       {
49652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49653       };
49654     } catch (Dali::DaliException e) {
49655       {
49656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49657       };
49658     } catch (...) {
49659       {
49660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49661       };
49662     }
49663   }
49664
49665   jresult = (void *)result;
49666   return jresult;
49667 }
49668
49669
49670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49671   void * jresult ;
49672   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49673   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49674   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49675
49676   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49677   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49678   if (!arg2) {
49679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49680     return 0;
49681   }
49682   {
49683     try {
49684       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49685     } catch (std::out_of_range& e) {
49686       {
49687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49688       };
49689     } catch (std::exception& e) {
49690       {
49691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49692       };
49693     } catch (Dali::DaliException e) {
49694       {
49695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49696       };
49697     } catch (...) {
49698       {
49699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49700       };
49701     }
49702   }
49703
49704   jresult = (void *)result;
49705   return jresult;
49706 }
49707
49708
49709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
49710   void * jresult ;
49711   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49712   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49713
49714   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49715   {
49716     try {
49717       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49718     } catch (std::out_of_range& e) {
49719       {
49720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49721       };
49722     } catch (std::exception& e) {
49723       {
49724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49725       };
49726     } catch (Dali::DaliException e) {
49727       {
49728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49729       };
49730     } catch (...) {
49731       {
49732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49733       };
49734     }
49735   }
49736
49737   jresult = (void *)result;
49738   return jresult;
49739 }
49740
49741
49742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
49743   void * jresult ;
49744   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49745   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49746
49747   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49748   {
49749     try {
49750       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
49751     } catch (std::out_of_range& e) {
49752       {
49753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49754       };
49755     } catch (std::exception& e) {
49756       {
49757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49758       };
49759     } catch (Dali::DaliException e) {
49760       {
49761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49762       };
49763     } catch (...) {
49764       {
49765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49766       };
49767     }
49768   }
49769
49770   jresult = (void *)result;
49771   return jresult;
49772 }
49773
49774
49775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49776   void * jresult ;
49777   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49778   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49779   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
49780
49781   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49782   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49783   {
49784     try {
49785       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
49786     } catch (std::out_of_range& e) {
49787       {
49788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49789       };
49790     } catch (std::exception& e) {
49791       {
49792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49793       };
49794     } catch (Dali::DaliException e) {
49795       {
49796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49797       };
49798     } catch (...) {
49799       {
49800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49801       };
49802     }
49803   }
49804
49805   jresult = (void *)result;
49806   return jresult;
49807 }
49808
49809
49810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
49811   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49812   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
49813
49814   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49815   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
49816   if (!arg2) {
49817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49818     return ;
49819   }
49820   {
49821     try {
49822       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
49823     } catch (std::out_of_range& e) {
49824       {
49825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49826       };
49827     } catch (std::exception& e) {
49828       {
49829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49830       };
49831     } catch (Dali::DaliException e) {
49832       {
49833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49834       };
49835     } catch (...) {
49836       {
49837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49838       };
49839     }
49840   }
49841
49842 }
49843
49844
49845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
49846   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49847   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49848   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49849
49850   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49851   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49852   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49853   if (!arg3) {
49854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49855     return ;
49856   }
49857   {
49858     try {
49859       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49860     } catch (std::out_of_range& e) {
49861       {
49862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49863       };
49864     } catch (std::exception& e) {
49865       {
49866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49867       };
49868     } catch (Dali::DaliException e) {
49869       {
49870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49871       };
49872     } catch (...) {
49873       {
49874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49875       };
49876     }
49877   }
49878
49879 }
49880
49881
49882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49883   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49884   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49885   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49886   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49887
49888   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49889   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49890   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49891   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
49892   {
49893     try {
49894       (arg1)->Insert(arg2,arg3,arg4);
49895     } catch (std::out_of_range& e) {
49896       {
49897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49898       };
49899     } catch (std::exception& e) {
49900       {
49901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49902       };
49903     } catch (Dali::DaliException e) {
49904       {
49905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49906       };
49907     } catch (...) {
49908       {
49909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49910       };
49911     }
49912   }
49913
49914 }
49915
49916
49917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
49918   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49919   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49920
49921   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49922   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49923   {
49924     try {
49925       (arg1)->Reserve(arg2);
49926     } catch (std::out_of_range& e) {
49927       {
49928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49929       };
49930     } catch (std::exception& e) {
49931       {
49932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49933       };
49934     } catch (Dali::DaliException e) {
49935       {
49936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49937       };
49938     } catch (...) {
49939       {
49940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49941       };
49942     }
49943   }
49944
49945 }
49946
49947
49948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49949   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49950   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49951
49952   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49953   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49954   {
49955     try {
49956       (arg1)->Resize(arg2);
49957     } catch (std::out_of_range& e) {
49958       {
49959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49960       };
49961     } catch (std::exception& e) {
49962       {
49963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49964       };
49965     } catch (Dali::DaliException e) {
49966       {
49967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49968       };
49969     } catch (...) {
49970       {
49971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49972       };
49973     }
49974   }
49975
49976 }
49977
49978
49979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
49980   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49981   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49982   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49983
49984   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49985   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49986   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49987   if (!arg3) {
49988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49989     return ;
49990   }
49991   {
49992     try {
49993       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49994     } catch (std::out_of_range& e) {
49995       {
49996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49997       };
49998     } catch (std::exception& e) {
49999       {
50000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50001       };
50002     } catch (Dali::DaliException e) {
50003       {
50004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50005       };
50006     } catch (...) {
50007       {
50008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50009       };
50010     }
50011   }
50012
50013 }
50014
50015
50016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
50017   void * jresult ;
50018   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50019   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50020   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50021
50022   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50023   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50024   {
50025     try {
50026       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
50027     } catch (std::out_of_range& e) {
50028       {
50029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50030       };
50031     } catch (std::exception& e) {
50032       {
50033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50034       };
50035     } catch (Dali::DaliException e) {
50036       {
50037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50038       };
50039     } catch (...) {
50040       {
50041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50042       };
50043     }
50044   }
50045
50046   jresult = (void *)result;
50047   return jresult;
50048 }
50049
50050
50051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50052   void * jresult ;
50053   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50054   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50055   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50056   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50057
50058   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50059   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50060   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50061   {
50062     try {
50063       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50064     } catch (std::out_of_range& e) {
50065       {
50066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50067       };
50068     } catch (std::exception& e) {
50069       {
50070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50071       };
50072     } catch (Dali::DaliException e) {
50073       {
50074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50075       };
50076     } catch (...) {
50077       {
50078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50079       };
50080     }
50081   }
50082
50083   jresult = (void *)result;
50084   return jresult;
50085 }
50086
50087
50088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50089   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50090   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50091
50092   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50093   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50094   {
50095     try {
50096       (arg1)->Remove(arg2);
50097     } catch (std::out_of_range& e) {
50098       {
50099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50100       };
50101     } catch (std::exception& e) {
50102       {
50103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50104       };
50105     } catch (Dali::DaliException e) {
50106       {
50107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50108       };
50109     } catch (...) {
50110       {
50111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50112       };
50113     }
50114   }
50115
50116 }
50117
50118
50119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50120   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50121   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50122
50123   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50124   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50125   if (!arg2) {
50126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50127     return ;
50128   }
50129   {
50130     try {
50131       (arg1)->Swap(*arg2);
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_VectorUint16Pair_Clear(void * jarg1) {
50155   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50156
50157   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50158   {
50159     try {
50160       (arg1)->Clear();
50161     } catch (std::out_of_range& e) {
50162       {
50163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50164       };
50165     } catch (std::exception& e) {
50166       {
50167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50168       };
50169     } catch (Dali::DaliException e) {
50170       {
50171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50172       };
50173     } catch (...) {
50174       {
50175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50176       };
50177     }
50178   }
50179
50180 }
50181
50182
50183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50184   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50185
50186   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50187   {
50188     try {
50189       (arg1)->Release();
50190     } catch (std::out_of_range& e) {
50191       {
50192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50193       };
50194     } catch (std::exception& e) {
50195       {
50196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50197       };
50198     } catch (Dali::DaliException e) {
50199       {
50200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50201       };
50202     } catch (...) {
50203       {
50204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50205       };
50206     }
50207   }
50208
50209 }
50210
50211
50212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50213   void * jresult ;
50214   Dali::Signal< void () > *result = 0 ;
50215
50216   {
50217     try {
50218       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50219     } catch (std::out_of_range& e) {
50220       {
50221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50222       };
50223     } catch (std::exception& e) {
50224       {
50225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50226       };
50227     } catch (Dali::DaliException e) {
50228       {
50229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50230       };
50231     } catch (...) {
50232       {
50233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50234       };
50235     }
50236   }
50237
50238   jresult = (void *)result;
50239   return jresult;
50240 }
50241
50242
50243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50244   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50245
50246   arg1 = (Dali::Signal< void () > *)jarg1;
50247   {
50248     try {
50249       delete arg1;
50250     } catch (std::out_of_range& e) {
50251       {
50252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50253       };
50254     } catch (std::exception& e) {
50255       {
50256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50257       };
50258     } catch (Dali::DaliException e) {
50259       {
50260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50261       };
50262     } catch (...) {
50263       {
50264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50265       };
50266     }
50267   }
50268
50269 }
50270
50271
50272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50273   unsigned int jresult ;
50274   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50275   bool result;
50276
50277   arg1 = (Dali::Signal< void () > *)jarg1;
50278   {
50279     try {
50280       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50281     } catch (std::out_of_range& e) {
50282       {
50283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50284       };
50285     } catch (std::exception& e) {
50286       {
50287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50288       };
50289     } catch (Dali::DaliException e) {
50290       {
50291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50292       };
50293     } catch (...) {
50294       {
50295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50296       };
50297     }
50298   }
50299
50300   jresult = result;
50301   return jresult;
50302 }
50303
50304
50305 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50306   unsigned long jresult ;
50307   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50308   std::size_t result;
50309
50310   arg1 = (Dali::Signal< void () > *)jarg1;
50311   {
50312     try {
50313       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50314     } catch (std::out_of_range& e) {
50315       {
50316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50317       };
50318     } catch (std::exception& e) {
50319       {
50320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50321       };
50322     } catch (Dali::DaliException e) {
50323       {
50324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50325       };
50326     } catch (...) {
50327       {
50328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50329       };
50330     }
50331   }
50332
50333   jresult = (unsigned long)result;
50334   return jresult;
50335 }
50336
50337
50338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50339   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50340   void (*arg2)() = (void (*)()) 0 ;
50341
50342   arg1 = (Dali::Signal< void () > *)jarg1;
50343   arg2 = (void (*)())jarg2;
50344   {
50345     try {
50346       (arg1)->Connect(arg2);
50347     } catch (std::out_of_range& e) {
50348       {
50349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50350       };
50351     } catch (std::exception& e) {
50352       {
50353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50354       };
50355     } catch (Dali::DaliException e) {
50356       {
50357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50358       };
50359     } catch (...) {
50360       {
50361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50362       };
50363     }
50364   }
50365
50366 }
50367
50368
50369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50370   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50371   void (*arg2)() = (void (*)()) 0 ;
50372
50373   arg1 = (Dali::Signal< void () > *)jarg1;
50374   arg2 = (void (*)())jarg2;
50375   {
50376     try {
50377       (arg1)->Disconnect(arg2);
50378     } catch (std::out_of_range& e) {
50379       {
50380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50381       };
50382     } catch (std::exception& e) {
50383       {
50384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50385       };
50386     } catch (Dali::DaliException e) {
50387       {
50388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50389       };
50390     } catch (...) {
50391       {
50392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50393       };
50394     }
50395   }
50396
50397 }
50398
50399
50400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50401   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50402   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50403   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50404
50405   arg1 = (Dali::Signal< void () > *)jarg1;
50406   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50407   arg3 = (Dali::FunctorDelegate *)jarg3;
50408   {
50409     try {
50410       (arg1)->Connect(arg2,arg3);
50411     } catch (std::out_of_range& e) {
50412       {
50413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50414       };
50415     } catch (std::exception& e) {
50416       {
50417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50418       };
50419     } catch (Dali::DaliException e) {
50420       {
50421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50422       };
50423     } catch (...) {
50424       {
50425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50426       };
50427     }
50428   }
50429
50430 }
50431
50432
50433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50434   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50435
50436   arg1 = (Dali::Signal< void () > *)jarg1;
50437   {
50438     try {
50439       (arg1)->Emit();
50440     } catch (std::out_of_range& e) {
50441       {
50442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50443       };
50444     } catch (std::exception& e) {
50445       {
50446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50447       };
50448     } catch (Dali::DaliException e) {
50449       {
50450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50451       };
50452     } catch (...) {
50453       {
50454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50455       };
50456     }
50457   }
50458
50459 }
50460
50461
50462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50463   unsigned int jresult ;
50464   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50465   bool result;
50466
50467   arg1 = (Dali::Signal< void (float) > *)jarg1;
50468   {
50469     try {
50470       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50471     } catch (std::out_of_range& e) {
50472       {
50473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50474       };
50475     } catch (std::exception& e) {
50476       {
50477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50478       };
50479     } catch (Dali::DaliException e) {
50480       {
50481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50482       };
50483     } catch (...) {
50484       {
50485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50486       };
50487     }
50488   }
50489
50490   jresult = result;
50491   return jresult;
50492 }
50493
50494
50495 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50496   unsigned long jresult ;
50497   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50498   std::size_t result;
50499
50500   arg1 = (Dali::Signal< void (float) > *)jarg1;
50501   {
50502     try {
50503       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50504     } catch (std::out_of_range& e) {
50505       {
50506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50507       };
50508     } catch (std::exception& e) {
50509       {
50510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50511       };
50512     } catch (Dali::DaliException e) {
50513       {
50514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50515       };
50516     } catch (...) {
50517       {
50518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50519       };
50520     }
50521   }
50522
50523   jresult = (unsigned long)result;
50524   return jresult;
50525 }
50526
50527
50528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50529   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50530   void (*arg2)(float) = (void (*)(float)) 0 ;
50531
50532   arg1 = (Dali::Signal< void (float) > *)jarg1;
50533   arg2 = (void (*)(float))jarg2;
50534   {
50535     try {
50536       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50537     } catch (std::out_of_range& e) {
50538       {
50539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50540       };
50541     } catch (std::exception& e) {
50542       {
50543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50544       };
50545     } catch (Dali::DaliException e) {
50546       {
50547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50548       };
50549     } catch (...) {
50550       {
50551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50552       };
50553     }
50554   }
50555
50556 }
50557
50558
50559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50560   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50561   void (*arg2)(float) = (void (*)(float)) 0 ;
50562
50563   arg1 = (Dali::Signal< void (float) > *)jarg1;
50564   arg2 = (void (*)(float))jarg2;
50565   {
50566     try {
50567       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50568     } catch (std::out_of_range& e) {
50569       {
50570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50571       };
50572     } catch (std::exception& e) {
50573       {
50574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50575       };
50576     } catch (Dali::DaliException e) {
50577       {
50578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50579       };
50580     } catch (...) {
50581       {
50582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50583       };
50584     }
50585   }
50586
50587 }
50588
50589
50590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
50591   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50592   float arg2 ;
50593
50594   arg1 = (Dali::Signal< void (float) > *)jarg1;
50595   arg2 = (float)jarg2;
50596   {
50597     try {
50598       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50599     } catch (std::out_of_range& e) {
50600       {
50601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50602       };
50603     } catch (std::exception& e) {
50604       {
50605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50606       };
50607     } catch (Dali::DaliException e) {
50608       {
50609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50610       };
50611     } catch (...) {
50612       {
50613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50614       };
50615     }
50616   }
50617
50618 }
50619
50620
50621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
50622   void * jresult ;
50623   Dali::Signal< void (float) > *result = 0 ;
50624
50625   {
50626     try {
50627       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50628     } catch (std::out_of_range& e) {
50629       {
50630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50631       };
50632     } catch (std::exception& e) {
50633       {
50634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50635       };
50636     } catch (Dali::DaliException e) {
50637       {
50638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50639       };
50640     } catch (...) {
50641       {
50642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50643       };
50644     }
50645   }
50646
50647   jresult = (void *)result;
50648   return jresult;
50649 }
50650
50651
50652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
50653   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50654
50655   arg1 = (Dali::Signal< void (float) > *)jarg1;
50656   {
50657     try {
50658       delete arg1;
50659     } catch (std::out_of_range& e) {
50660       {
50661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50662       };
50663     } catch (std::exception& e) {
50664       {
50665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50666       };
50667     } catch (Dali::DaliException e) {
50668       {
50669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50670       };
50671     } catch (...) {
50672       {
50673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50674       };
50675     }
50676   }
50677
50678 }
50679
50680
50681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
50682   unsigned int jresult ;
50683   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50684   bool result;
50685
50686   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50687   {
50688     try {
50689       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50690     } catch (std::out_of_range& e) {
50691       {
50692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50693       };
50694     } catch (std::exception& e) {
50695       {
50696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50697       };
50698     } catch (Dali::DaliException e) {
50699       {
50700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50701       };
50702     } catch (...) {
50703       {
50704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50705       };
50706     }
50707   }
50708
50709   jresult = result;
50710   return jresult;
50711 }
50712
50713
50714 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50715   unsigned long jresult ;
50716   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50717   std::size_t result;
50718
50719   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50720   {
50721     try {
50722       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50723     } catch (std::out_of_range& e) {
50724       {
50725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50726       };
50727     } catch (std::exception& e) {
50728       {
50729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50730       };
50731     } catch (Dali::DaliException e) {
50732       {
50733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50734       };
50735     } catch (...) {
50736       {
50737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50738       };
50739     }
50740   }
50741
50742   jresult = (unsigned long)result;
50743   return jresult;
50744 }
50745
50746
50747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
50748   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50749   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50750
50751   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50752   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50753   {
50754     try {
50755       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
50756     } catch (std::out_of_range& e) {
50757       {
50758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50759       };
50760     } catch (std::exception& e) {
50761       {
50762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50763       };
50764     } catch (Dali::DaliException e) {
50765       {
50766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50767       };
50768     } catch (...) {
50769       {
50770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50771       };
50772     }
50773   }
50774
50775 }
50776
50777
50778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
50779   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50780   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50781
50782   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50783   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50784   {
50785     try {
50786       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
50787     } catch (std::out_of_range& e) {
50788       {
50789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50790       };
50791     } catch (std::exception& e) {
50792       {
50793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50794       };
50795     } catch (Dali::DaliException e) {
50796       {
50797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50798       };
50799     } catch (...) {
50800       {
50801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50802       };
50803     }
50804   }
50805
50806 }
50807
50808
50809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
50810   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50811   Dali::BaseHandle arg2 ;
50812   Dali::BaseHandle *argp2 ;
50813
50814   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50815   argp2 = (Dali::BaseHandle *)jarg2;
50816   if (!argp2) {
50817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50818     return ;
50819   }
50820   arg2 = *argp2;
50821   {
50822     try {
50823       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
50824     } catch (std::out_of_range& e) {
50825       {
50826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50827       };
50828     } catch (std::exception& e) {
50829       {
50830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50831       };
50832     } catch (Dali::DaliException e) {
50833       {
50834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50835       };
50836     } catch (...) {
50837       {
50838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50839       };
50840     }
50841   }
50842
50843 }
50844
50845
50846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
50847   void * jresult ;
50848   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
50849
50850   {
50851     try {
50852       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
50853     } catch (std::out_of_range& e) {
50854       {
50855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50856       };
50857     } catch (std::exception& e) {
50858       {
50859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50860       };
50861     } catch (Dali::DaliException e) {
50862       {
50863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50864       };
50865     } catch (...) {
50866       {
50867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50868       };
50869     }
50870   }
50871
50872   jresult = (void *)result;
50873   return jresult;
50874 }
50875
50876
50877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
50878   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50879
50880   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50881   {
50882     try {
50883       delete arg1;
50884     } catch (std::out_of_range& e) {
50885       {
50886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50887       };
50888     } catch (std::exception& e) {
50889       {
50890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50891       };
50892     } catch (Dali::DaliException e) {
50893       {
50894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50895       };
50896     } catch (...) {
50897       {
50898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50899       };
50900     }
50901   }
50902
50903 }
50904
50905
50906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
50907   unsigned int jresult ;
50908   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50909   bool result;
50910
50911   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50912   {
50913     try {
50914       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50915     } catch (std::out_of_range& e) {
50916       {
50917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50918       };
50919     } catch (std::exception& e) {
50920       {
50921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50922       };
50923     } catch (Dali::DaliException e) {
50924       {
50925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50926       };
50927     } catch (...) {
50928       {
50929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50930       };
50931     }
50932   }
50933
50934   jresult = result;
50935   return jresult;
50936 }
50937
50938
50939 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
50940   unsigned long jresult ;
50941   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50942   std::size_t result;
50943
50944   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50945   {
50946     try {
50947       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50948     } catch (std::out_of_range& e) {
50949       {
50950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50951       };
50952     } catch (std::exception& e) {
50953       {
50954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50955       };
50956     } catch (Dali::DaliException e) {
50957       {
50958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50959       };
50960     } catch (...) {
50961       {
50962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50963       };
50964     }
50965   }
50966
50967   jresult = (unsigned long)result;
50968   return jresult;
50969 }
50970
50971
50972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
50973   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50974   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50975
50976   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50977   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50978   {
50979     try {
50980       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
50981     } catch (std::out_of_range& e) {
50982       {
50983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50984       };
50985     } catch (std::exception& e) {
50986       {
50987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50988       };
50989     } catch (Dali::DaliException e) {
50990       {
50991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50992       };
50993     } catch (...) {
50994       {
50995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50996       };
50997     }
50998   }
50999
51000 }
51001
51002
51003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
51004   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51005   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51006
51007   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51008   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51009   {
51010     try {
51011       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
51012     } catch (std::out_of_range& e) {
51013       {
51014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51015       };
51016     } catch (std::exception& e) {
51017       {
51018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51019       };
51020     } catch (Dali::DaliException e) {
51021       {
51022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51023       };
51024     } catch (...) {
51025       {
51026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51027       };
51028     }
51029   }
51030
51031 }
51032
51033
51034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
51035   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51036   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
51037
51038   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51039   arg2 = (Dali::RefObject *)jarg2;
51040   {
51041     try {
51042       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
51043     } catch (std::out_of_range& e) {
51044       {
51045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51046       };
51047     } catch (std::exception& e) {
51048       {
51049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51050       };
51051     } catch (Dali::DaliException e) {
51052       {
51053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51054       };
51055     } catch (...) {
51056       {
51057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51058       };
51059     }
51060   }
51061
51062 }
51063
51064
51065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51066   void * jresult ;
51067   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51068
51069   {
51070     try {
51071       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51072     } catch (std::out_of_range& e) {
51073       {
51074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51075       };
51076     } catch (std::exception& e) {
51077       {
51078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51079       };
51080     } catch (Dali::DaliException e) {
51081       {
51082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51083       };
51084     } catch (...) {
51085       {
51086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51087       };
51088     }
51089   }
51090
51091   jresult = (void *)result;
51092   return jresult;
51093 }
51094
51095
51096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51097   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51098
51099   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51100   {
51101     try {
51102       delete arg1;
51103     } catch (std::out_of_range& e) {
51104       {
51105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51106       };
51107     } catch (std::exception& e) {
51108       {
51109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51110       };
51111     } catch (Dali::DaliException e) {
51112       {
51113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51114       };
51115     } catch (...) {
51116       {
51117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51118       };
51119     }
51120   }
51121
51122 }
51123
51124
51125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51126   unsigned int jresult ;
51127   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51128   bool result;
51129
51130   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51131   {
51132     try {
51133       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51134     } catch (std::out_of_range& e) {
51135       {
51136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51137       };
51138     } catch (std::exception& e) {
51139       {
51140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51141       };
51142     } catch (Dali::DaliException e) {
51143       {
51144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51145       };
51146     } catch (...) {
51147       {
51148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51149       };
51150     }
51151   }
51152
51153   jresult = result;
51154   return jresult;
51155 }
51156
51157
51158 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51159   unsigned long jresult ;
51160   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51161   std::size_t result;
51162
51163   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51164   {
51165     try {
51166       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51167     } catch (std::out_of_range& e) {
51168       {
51169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51170       };
51171     } catch (std::exception& e) {
51172       {
51173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51174       };
51175     } catch (Dali::DaliException e) {
51176       {
51177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51178       };
51179     } catch (...) {
51180       {
51181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51182       };
51183     }
51184   }
51185
51186   jresult = (unsigned long)result;
51187   return jresult;
51188 }
51189
51190
51191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51192   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51193   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51194
51195   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51196   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51197   {
51198     try {
51199       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51200     } catch (std::out_of_range& e) {
51201       {
51202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51203       };
51204     } catch (std::exception& e) {
51205       {
51206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51207       };
51208     } catch (Dali::DaliException e) {
51209       {
51210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51211       };
51212     } catch (...) {
51213       {
51214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51215       };
51216     }
51217   }
51218
51219 }
51220
51221
51222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51223   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51224   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51225
51226   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51227   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51228   {
51229     try {
51230       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51231     } catch (std::out_of_range& e) {
51232       {
51233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51234       };
51235     } catch (std::exception& e) {
51236       {
51237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51238       };
51239     } catch (Dali::DaliException e) {
51240       {
51241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51242       };
51243     } catch (...) {
51244       {
51245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51246       };
51247     }
51248   }
51249
51250 }
51251
51252
51253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51254   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51255   Dali::PropertyNotification *arg2 = 0 ;
51256
51257   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51258   arg2 = (Dali::PropertyNotification *)jarg2;
51259   if (!arg2) {
51260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51261     return ;
51262   }
51263   {
51264     try {
51265       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51266     } catch (std::out_of_range& e) {
51267       {
51268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51269       };
51270     } catch (std::exception& e) {
51271       {
51272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51273       };
51274     } catch (Dali::DaliException e) {
51275       {
51276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51277       };
51278     } catch (...) {
51279       {
51280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51281       };
51282     }
51283   }
51284
51285 }
51286
51287
51288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51289   void * jresult ;
51290   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51291
51292   {
51293     try {
51294       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51295     } catch (std::out_of_range& e) {
51296       {
51297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51298       };
51299     } catch (std::exception& e) {
51300       {
51301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51302       };
51303     } catch (Dali::DaliException e) {
51304       {
51305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51306       };
51307     } catch (...) {
51308       {
51309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51310       };
51311     }
51312   }
51313
51314   jresult = (void *)result;
51315   return jresult;
51316 }
51317
51318
51319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51320   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51321
51322   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51323   {
51324     try {
51325       delete arg1;
51326     } catch (std::out_of_range& e) {
51327       {
51328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51329       };
51330     } catch (std::exception& e) {
51331       {
51332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51333       };
51334     } catch (Dali::DaliException e) {
51335       {
51336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51337       };
51338     } catch (...) {
51339       {
51340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51341       };
51342     }
51343   }
51344
51345 }
51346
51347
51348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51349   void * jresult ;
51350   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51351
51352   {
51353     try {
51354       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51355     } catch (std::out_of_range& e) {
51356       {
51357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51358       };
51359     } catch (std::exception& e) {
51360       {
51361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51362       };
51363     } catch (Dali::DaliException e) {
51364       {
51365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51366       };
51367     } catch (...) {
51368       {
51369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51370       };
51371     }
51372   }
51373
51374   jresult = (void *)result;
51375   return jresult;
51376 }
51377
51378
51379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51380   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51381
51382   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51383   {
51384     try {
51385       delete arg1;
51386     } catch (std::out_of_range& e) {
51387       {
51388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51389       };
51390     } catch (std::exception& e) {
51391       {
51392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51393       };
51394     } catch (Dali::DaliException e) {
51395       {
51396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51397       };
51398     } catch (...) {
51399       {
51400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51401       };
51402     }
51403   }
51404
51405 }
51406
51407
51408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51409   unsigned int jresult ;
51410   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51411   bool result;
51412
51413   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51414   {
51415     try {
51416       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);
51417     } catch (std::out_of_range& e) {
51418       {
51419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51420       };
51421     } catch (std::exception& e) {
51422       {
51423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51424       };
51425     } catch (Dali::DaliException e) {
51426       {
51427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51428       };
51429     } catch (...) {
51430       {
51431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51432       };
51433     }
51434   }
51435
51436   jresult = result;
51437   return jresult;
51438 }
51439
51440
51441 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51442   unsigned long jresult ;
51443   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51444   std::size_t result;
51445
51446   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51447   {
51448     try {
51449       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);
51450     } catch (std::out_of_range& e) {
51451       {
51452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51453       };
51454     } catch (std::exception& e) {
51455       {
51456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51457       };
51458     } catch (Dali::DaliException e) {
51459       {
51460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51461       };
51462     } catch (...) {
51463       {
51464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51465       };
51466     }
51467   }
51468
51469   jresult = (unsigned long)result;
51470   return jresult;
51471 }
51472
51473
51474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51475   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51476   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51477
51478   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51479   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51480   {
51481     try {
51482       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51483     } catch (std::out_of_range& e) {
51484       {
51485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51486       };
51487     } catch (std::exception& e) {
51488       {
51489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51490       };
51491     } catch (Dali::DaliException e) {
51492       {
51493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51494       };
51495     } catch (...) {
51496       {
51497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51498       };
51499     }
51500   }
51501
51502 }
51503
51504
51505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51506   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51507   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51508
51509   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51510   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51511   {
51512     try {
51513       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51514     } catch (std::out_of_range& e) {
51515       {
51516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51517       };
51518     } catch (std::exception& e) {
51519       {
51520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51521       };
51522     } catch (Dali::DaliException e) {
51523       {
51524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51525       };
51526     } catch (...) {
51527       {
51528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51529       };
51530     }
51531   }
51532
51533 }
51534
51535
51536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51537   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51538   Dali::Actor arg2 ;
51539   Dali::LongPressGesture *arg3 = 0 ;
51540   Dali::Actor *argp2 ;
51541
51542   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51543   argp2 = (Dali::Actor *)jarg2;
51544   if (!argp2) {
51545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51546     return ;
51547   }
51548   arg2 = *argp2;
51549   arg3 = (Dali::LongPressGesture *)jarg3;
51550   if (!arg3) {
51551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51552     return ;
51553   }
51554   {
51555     try {
51556       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51557     } catch (std::out_of_range& e) {
51558       {
51559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51560       };
51561     } catch (std::exception& e) {
51562       {
51563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51564       };
51565     } catch (Dali::DaliException e) {
51566       {
51567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51568       };
51569     } catch (...) {
51570       {
51571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51572       };
51573     }
51574   }
51575
51576 }
51577
51578
51579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
51580   void * jresult ;
51581   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51582
51583   {
51584     try {
51585       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51586     } catch (std::out_of_range& e) {
51587       {
51588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51589       };
51590     } catch (std::exception& e) {
51591       {
51592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51593       };
51594     } catch (Dali::DaliException e) {
51595       {
51596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51597       };
51598     } catch (...) {
51599       {
51600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51601       };
51602     }
51603   }
51604
51605   jresult = (void *)result;
51606   return jresult;
51607 }
51608
51609
51610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
51611   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51612
51613   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51614   {
51615     try {
51616       delete arg1;
51617     } catch (std::out_of_range& e) {
51618       {
51619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51620       };
51621     } catch (std::exception& e) {
51622       {
51623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51624       };
51625     } catch (Dali::DaliException e) {
51626       {
51627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51628       };
51629     } catch (...) {
51630       {
51631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51632       };
51633     }
51634   }
51635
51636 }
51637
51638
51639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
51640   unsigned int jresult ;
51641   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51642   bool result;
51643
51644   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51645   {
51646     try {
51647       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);
51648     } catch (std::out_of_range& e) {
51649       {
51650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51651       };
51652     } catch (std::exception& e) {
51653       {
51654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51655       };
51656     } catch (Dali::DaliException e) {
51657       {
51658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51659       };
51660     } catch (...) {
51661       {
51662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51663       };
51664     }
51665   }
51666
51667   jresult = result;
51668   return jresult;
51669 }
51670
51671
51672 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51673   unsigned long jresult ;
51674   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51675   std::size_t result;
51676
51677   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51678   {
51679     try {
51680       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);
51681     } catch (std::out_of_range& e) {
51682       {
51683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51684       };
51685     } catch (std::exception& e) {
51686       {
51687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51688       };
51689     } catch (Dali::DaliException e) {
51690       {
51691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51692       };
51693     } catch (...) {
51694       {
51695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51696       };
51697     }
51698   }
51699
51700   jresult = (unsigned long)result;
51701   return jresult;
51702 }
51703
51704
51705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51706   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51707   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51708
51709   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51710   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51711   {
51712     try {
51713       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51714     } catch (std::out_of_range& e) {
51715       {
51716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51717       };
51718     } catch (std::exception& e) {
51719       {
51720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51721       };
51722     } catch (Dali::DaliException e) {
51723       {
51724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51725       };
51726     } catch (...) {
51727       {
51728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51729       };
51730     }
51731   }
51732
51733 }
51734
51735
51736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
51737   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51738   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51739
51740   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51741   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51742   {
51743     try {
51744       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51745     } catch (std::out_of_range& e) {
51746       {
51747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51748       };
51749     } catch (std::exception& e) {
51750       {
51751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51752       };
51753     } catch (Dali::DaliException e) {
51754       {
51755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51756       };
51757     } catch (...) {
51758       {
51759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51760       };
51761     }
51762   }
51763
51764 }
51765
51766
51767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51768   unsigned int jresult ;
51769   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51770   Dali::Actor arg2 ;
51771   Dali::TouchData *arg3 = 0 ;
51772   Dali::Actor *argp2 ;
51773   bool result;
51774
51775   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51776   argp2 = (Dali::Actor *)jarg2;
51777   if (!argp2) {
51778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51779     return 0;
51780   }
51781   arg2 = *argp2;
51782   arg3 = (Dali::TouchData *)jarg3;
51783   if (!arg3) {
51784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51785     return 0;
51786   }
51787   {
51788     try {
51789       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
51790     } catch (std::out_of_range& e) {
51791       {
51792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51793       };
51794     } catch (std::exception& e) {
51795       {
51796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51797       };
51798     } catch (Dali::DaliException e) {
51799       {
51800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51801       };
51802     } catch (...) {
51803       {
51804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51805       };
51806     }
51807   }
51808
51809   jresult = result;
51810   return jresult;
51811 }
51812
51813
51814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
51815   void * jresult ;
51816   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
51817
51818   {
51819     try {
51820       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
51821     } catch (std::out_of_range& e) {
51822       {
51823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51824       };
51825     } catch (std::exception& e) {
51826       {
51827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51828       };
51829     } catch (Dali::DaliException e) {
51830       {
51831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51832       };
51833     } catch (...) {
51834       {
51835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51836       };
51837     }
51838   }
51839
51840   jresult = (void *)result;
51841   return jresult;
51842 }
51843
51844
51845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
51846   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51847
51848   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51849   {
51850     try {
51851       delete arg1;
51852     } catch (std::out_of_range& e) {
51853       {
51854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51855       };
51856     } catch (std::exception& e) {
51857       {
51858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51859       };
51860     } catch (Dali::DaliException e) {
51861       {
51862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51863       };
51864     } catch (...) {
51865       {
51866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51867       };
51868     }
51869   }
51870
51871 }
51872
51873
51874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
51875   unsigned int jresult ;
51876   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51877   bool result;
51878
51879   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51880   {
51881     try {
51882       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);
51883     } catch (std::out_of_range& e) {
51884       {
51885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51886       };
51887     } catch (std::exception& e) {
51888       {
51889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51890       };
51891     } catch (Dali::DaliException e) {
51892       {
51893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51894       };
51895     } catch (...) {
51896       {
51897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51898       };
51899     }
51900   }
51901
51902   jresult = result;
51903   return jresult;
51904 }
51905
51906
51907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
51908   unsigned long jresult ;
51909   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51910   std::size_t result;
51911
51912   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51913   {
51914     try {
51915       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);
51916     } catch (std::out_of_range& e) {
51917       {
51918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51919       };
51920     } catch (std::exception& e) {
51921       {
51922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51923       };
51924     } catch (Dali::DaliException e) {
51925       {
51926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51927       };
51928     } catch (...) {
51929       {
51930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51931       };
51932     }
51933   }
51934
51935   jresult = (unsigned long)result;
51936   return jresult;
51937 }
51938
51939
51940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
51941   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51942   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51943
51944   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51945   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51946   {
51947     try {
51948       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51949     } catch (std::out_of_range& e) {
51950       {
51951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51952       };
51953     } catch (std::exception& e) {
51954       {
51955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51956       };
51957     } catch (Dali::DaliException e) {
51958       {
51959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51960       };
51961     } catch (...) {
51962       {
51963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51964       };
51965     }
51966   }
51967
51968 }
51969
51970
51971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
51972   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51973   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51974
51975   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51976   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51977   {
51978     try {
51979       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51980     } catch (std::out_of_range& e) {
51981       {
51982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51983       };
51984     } catch (std::exception& e) {
51985       {
51986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51987       };
51988     } catch (Dali::DaliException e) {
51989       {
51990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51991       };
51992     } catch (...) {
51993       {
51994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51995       };
51996     }
51997   }
51998
51999 }
52000
52001
52002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52003   unsigned int jresult ;
52004   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52005   Dali::Actor arg2 ;
52006   Dali::HoverEvent *arg3 = 0 ;
52007   Dali::Actor *argp2 ;
52008   bool result;
52009
52010   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52011   argp2 = (Dali::Actor *)jarg2;
52012   if (!argp2) {
52013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52014     return 0;
52015   }
52016   arg2 = *argp2;
52017   arg3 = (Dali::HoverEvent *)jarg3;
52018   if (!arg3) {
52019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
52020     return 0;
52021   }
52022   {
52023     try {
52024       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
52025     } catch (std::out_of_range& e) {
52026       {
52027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52028       };
52029     } catch (std::exception& e) {
52030       {
52031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52032       };
52033     } catch (Dali::DaliException e) {
52034       {
52035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52036       };
52037     } catch (...) {
52038       {
52039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52040       };
52041     }
52042   }
52043
52044   jresult = result;
52045   return jresult;
52046 }
52047
52048
52049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
52050   void * jresult ;
52051   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
52052
52053   {
52054     try {
52055       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
52056     } catch (std::out_of_range& e) {
52057       {
52058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52059       };
52060     } catch (std::exception& e) {
52061       {
52062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52063       };
52064     } catch (Dali::DaliException e) {
52065       {
52066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52067       };
52068     } catch (...) {
52069       {
52070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52071       };
52072     }
52073   }
52074
52075   jresult = (void *)result;
52076   return jresult;
52077 }
52078
52079
52080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52081   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52082
52083   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52084   {
52085     try {
52086       delete arg1;
52087     } catch (std::out_of_range& e) {
52088       {
52089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52090       };
52091     } catch (std::exception& e) {
52092       {
52093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52094       };
52095     } catch (Dali::DaliException e) {
52096       {
52097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52098       };
52099     } catch (...) {
52100       {
52101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52102       };
52103     }
52104   }
52105
52106 }
52107
52108
52109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52110   unsigned int jresult ;
52111   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52112   bool result;
52113
52114   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52115   {
52116     try {
52117       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);
52118     } catch (std::out_of_range& e) {
52119       {
52120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52121       };
52122     } catch (std::exception& e) {
52123       {
52124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52125       };
52126     } catch (Dali::DaliException e) {
52127       {
52128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52129       };
52130     } catch (...) {
52131       {
52132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52133       };
52134     }
52135   }
52136
52137   jresult = result;
52138   return jresult;
52139 }
52140
52141
52142 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52143   unsigned long jresult ;
52144   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52145   std::size_t result;
52146
52147   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52148   {
52149     try {
52150       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);
52151     } catch (std::out_of_range& e) {
52152       {
52153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52154       };
52155     } catch (std::exception& e) {
52156       {
52157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52158       };
52159     } catch (Dali::DaliException e) {
52160       {
52161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52162       };
52163     } catch (...) {
52164       {
52165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52166       };
52167     }
52168   }
52169
52170   jresult = (unsigned long)result;
52171   return jresult;
52172 }
52173
52174
52175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52176   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52177   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52178
52179   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52180   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52181   {
52182     try {
52183       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52184     } catch (std::out_of_range& e) {
52185       {
52186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52187       };
52188     } catch (std::exception& e) {
52189       {
52190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52191       };
52192     } catch (Dali::DaliException e) {
52193       {
52194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52195       };
52196     } catch (...) {
52197       {
52198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52199       };
52200     }
52201   }
52202
52203 }
52204
52205
52206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52207   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52208   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52209
52210   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52211   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52212   {
52213     try {
52214       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52215     } catch (std::out_of_range& e) {
52216       {
52217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52218       };
52219     } catch (std::exception& e) {
52220       {
52221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52222       };
52223     } catch (Dali::DaliException e) {
52224       {
52225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52226       };
52227     } catch (...) {
52228       {
52229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52230       };
52231     }
52232   }
52233
52234 }
52235
52236
52237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52238   unsigned int jresult ;
52239   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52240   Dali::Actor arg2 ;
52241   Dali::WheelEvent *arg3 = 0 ;
52242   Dali::Actor *argp2 ;
52243   bool result;
52244
52245   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52246   argp2 = (Dali::Actor *)jarg2;
52247   if (!argp2) {
52248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52249     return 0;
52250   }
52251   arg2 = *argp2;
52252   arg3 = (Dali::WheelEvent *)jarg3;
52253   if (!arg3) {
52254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52255     return 0;
52256   }
52257   {
52258     try {
52259       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52260     } catch (std::out_of_range& e) {
52261       {
52262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52263       };
52264     } catch (std::exception& e) {
52265       {
52266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52267       };
52268     } catch (Dali::DaliException e) {
52269       {
52270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52271       };
52272     } catch (...) {
52273       {
52274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52275       };
52276     }
52277   }
52278
52279   jresult = result;
52280   return jresult;
52281 }
52282
52283
52284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52285   void * jresult ;
52286   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52287
52288   {
52289     try {
52290       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52291     } catch (std::out_of_range& e) {
52292       {
52293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52294       };
52295     } catch (std::exception& e) {
52296       {
52297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52298       };
52299     } catch (Dali::DaliException e) {
52300       {
52301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52302       };
52303     } catch (...) {
52304       {
52305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52306       };
52307     }
52308   }
52309
52310   jresult = (void *)result;
52311   return jresult;
52312 }
52313
52314
52315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52316   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52317
52318   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52319   {
52320     try {
52321       delete arg1;
52322     } catch (std::out_of_range& e) {
52323       {
52324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52325       };
52326     } catch (std::exception& e) {
52327       {
52328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52329       };
52330     } catch (Dali::DaliException e) {
52331       {
52332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52333       };
52334     } catch (...) {
52335       {
52336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52337       };
52338     }
52339   }
52340
52341 }
52342
52343
52344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52345   unsigned int jresult ;
52346   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52347   bool result;
52348
52349   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52350   {
52351     try {
52352       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52353     } catch (std::out_of_range& e) {
52354       {
52355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52356       };
52357     } catch (std::exception& e) {
52358       {
52359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52360       };
52361     } catch (Dali::DaliException e) {
52362       {
52363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52364       };
52365     } catch (...) {
52366       {
52367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52368       };
52369     }
52370   }
52371
52372   jresult = result;
52373   return jresult;
52374 }
52375
52376
52377 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52378   unsigned long jresult ;
52379   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52380   std::size_t result;
52381
52382   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52383   {
52384     try {
52385       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52386     } catch (std::out_of_range& e) {
52387       {
52388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52389       };
52390     } catch (std::exception& e) {
52391       {
52392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52393       };
52394     } catch (Dali::DaliException e) {
52395       {
52396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52397       };
52398     } catch (...) {
52399       {
52400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52401       };
52402     }
52403   }
52404
52405   jresult = (unsigned long)result;
52406   return jresult;
52407 }
52408
52409
52410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52411   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52412   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52413
52414   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52415   arg2 = (void (*)(Dali::Actor))jarg2;
52416   {
52417     try {
52418       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52419     } catch (std::out_of_range& e) {
52420       {
52421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52422       };
52423     } catch (std::exception& e) {
52424       {
52425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52426       };
52427     } catch (Dali::DaliException e) {
52428       {
52429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52430       };
52431     } catch (...) {
52432       {
52433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52434       };
52435     }
52436   }
52437
52438 }
52439
52440
52441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52442   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52443   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52444
52445   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52446   arg2 = (void (*)(Dali::Actor))jarg2;
52447   {
52448     try {
52449       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52450     } catch (std::out_of_range& e) {
52451       {
52452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52453       };
52454     } catch (std::exception& e) {
52455       {
52456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52457       };
52458     } catch (Dali::DaliException e) {
52459       {
52460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52461       };
52462     } catch (...) {
52463       {
52464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52465       };
52466     }
52467   }
52468
52469 }
52470
52471
52472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52473   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52474   Dali::Actor arg2 ;
52475   Dali::Actor *argp2 ;
52476
52477   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52478   argp2 = (Dali::Actor *)jarg2;
52479   if (!argp2) {
52480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52481     return ;
52482   }
52483   arg2 = *argp2;
52484   {
52485     try {
52486       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52487     } catch (std::out_of_range& e) {
52488       {
52489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52490       };
52491     } catch (std::exception& e) {
52492       {
52493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52494       };
52495     } catch (Dali::DaliException e) {
52496       {
52497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52498       };
52499     } catch (...) {
52500       {
52501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52502       };
52503     }
52504   }
52505
52506 }
52507
52508
52509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52510   void * jresult ;
52511   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52512
52513   {
52514     try {
52515       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52516     } catch (std::out_of_range& e) {
52517       {
52518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52519       };
52520     } catch (std::exception& e) {
52521       {
52522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52523       };
52524     } catch (Dali::DaliException e) {
52525       {
52526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52527       };
52528     } catch (...) {
52529       {
52530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52531       };
52532     }
52533   }
52534
52535   jresult = (void *)result;
52536   return jresult;
52537 }
52538
52539
52540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52541   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52542
52543   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52544   {
52545     try {
52546       delete arg1;
52547     } catch (std::out_of_range& e) {
52548       {
52549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52550       };
52551     } catch (std::exception& e) {
52552       {
52553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52554       };
52555     } catch (Dali::DaliException e) {
52556       {
52557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52558       };
52559     } catch (...) {
52560       {
52561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52562       };
52563     }
52564   }
52565
52566 }
52567
52568
52569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
52570   unsigned int jresult ;
52571   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52572   bool result;
52573
52574   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52575   {
52576     try {
52577       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52578     } catch (std::out_of_range& e) {
52579       {
52580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52581       };
52582     } catch (std::exception& e) {
52583       {
52584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52585       };
52586     } catch (Dali::DaliException e) {
52587       {
52588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52589       };
52590     } catch (...) {
52591       {
52592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52593       };
52594     }
52595   }
52596
52597   jresult = result;
52598   return jresult;
52599 }
52600
52601
52602 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
52603   unsigned long jresult ;
52604   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52605   std::size_t result;
52606
52607   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52608   {
52609     try {
52610       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52611     } catch (std::out_of_range& e) {
52612       {
52613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52614       };
52615     } catch (std::exception& e) {
52616       {
52617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52618       };
52619     } catch (Dali::DaliException e) {
52620       {
52621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52622       };
52623     } catch (...) {
52624       {
52625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52626       };
52627     }
52628   }
52629
52630   jresult = (unsigned long)result;
52631   return jresult;
52632 }
52633
52634
52635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52636   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52637   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52638
52639   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52640   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52641   {
52642     try {
52643       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52644     } catch (std::out_of_range& e) {
52645       {
52646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52647       };
52648     } catch (std::exception& e) {
52649       {
52650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52651       };
52652     } catch (Dali::DaliException e) {
52653       {
52654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52655       };
52656     } catch (...) {
52657       {
52658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52659       };
52660     }
52661   }
52662
52663 }
52664
52665
52666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52667   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52668   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52669
52670   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52671   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52672   {
52673     try {
52674       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52675     } catch (std::out_of_range& e) {
52676       {
52677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52678       };
52679     } catch (std::exception& e) {
52680       {
52681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52682       };
52683     } catch (Dali::DaliException e) {
52684       {
52685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52686       };
52687     } catch (...) {
52688       {
52689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52690       };
52691     }
52692   }
52693
52694 }
52695
52696
52697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52698   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52699   Dali::KeyEvent *arg2 = 0 ;
52700
52701   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52702   arg2 = (Dali::KeyEvent *)jarg2;
52703   if (!arg2) {
52704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52705     return ;
52706   }
52707   {
52708     try {
52709       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52710     } catch (std::out_of_range& e) {
52711       {
52712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52713       };
52714     } catch (std::exception& e) {
52715       {
52716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52717       };
52718     } catch (Dali::DaliException e) {
52719       {
52720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52721       };
52722     } catch (...) {
52723       {
52724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52725       };
52726     }
52727   }
52728
52729 }
52730
52731
52732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
52733   void * jresult ;
52734   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
52735
52736   {
52737     try {
52738       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
52739     } catch (std::out_of_range& e) {
52740       {
52741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52742       };
52743     } catch (std::exception& e) {
52744       {
52745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52746       };
52747     } catch (Dali::DaliException e) {
52748       {
52749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52750       };
52751     } catch (...) {
52752       {
52753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52754       };
52755     }
52756   }
52757
52758   jresult = (void *)result;
52759   return jresult;
52760 }
52761
52762
52763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
52764   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52765
52766   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52767   {
52768     try {
52769       delete arg1;
52770     } catch (std::out_of_range& e) {
52771       {
52772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52773       };
52774     } catch (std::exception& e) {
52775       {
52776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52777       };
52778     } catch (Dali::DaliException e) {
52779       {
52780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52781       };
52782     } catch (...) {
52783       {
52784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52785       };
52786     }
52787   }
52788
52789 }
52790
52791
52792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
52793   unsigned int jresult ;
52794   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52795   bool result;
52796
52797   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52798   {
52799     try {
52800       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52801     } catch (std::out_of_range& e) {
52802       {
52803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52804       };
52805     } catch (std::exception& e) {
52806       {
52807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52808       };
52809     } catch (Dali::DaliException e) {
52810       {
52811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52812       };
52813     } catch (...) {
52814       {
52815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52816       };
52817     }
52818   }
52819
52820   jresult = result;
52821   return jresult;
52822 }
52823
52824
52825 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
52826   unsigned long jresult ;
52827   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52828   std::size_t result;
52829
52830   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52831   {
52832     try {
52833       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52834     } catch (std::out_of_range& e) {
52835       {
52836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52837       };
52838     } catch (std::exception& e) {
52839       {
52840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52841       };
52842     } catch (Dali::DaliException e) {
52843       {
52844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52845       };
52846     } catch (...) {
52847       {
52848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52849       };
52850     }
52851   }
52852
52853   jresult = (unsigned long)result;
52854   return jresult;
52855 }
52856
52857
52858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
52859   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52860   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
52861
52862   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52863   arg2 = (void (*)(Dali::TouchData const &))jarg2;
52864   {
52865     try {
52866       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52867     } catch (std::out_of_range& e) {
52868       {
52869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52870       };
52871     } catch (std::exception& e) {
52872       {
52873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52874       };
52875     } catch (Dali::DaliException e) {
52876       {
52877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52878       };
52879     } catch (...) {
52880       {
52881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52882       };
52883     }
52884   }
52885
52886 }
52887
52888
52889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
52890   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52891   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
52892
52893   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52894   arg2 = (void (*)(Dali::TouchData const &))jarg2;
52895   {
52896     try {
52897       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52898     } catch (std::out_of_range& e) {
52899       {
52900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52901       };
52902     } catch (std::exception& e) {
52903       {
52904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52905       };
52906     } catch (Dali::DaliException e) {
52907       {
52908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52909       };
52910     } catch (...) {
52911       {
52912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52913       };
52914     }
52915   }
52916
52917 }
52918
52919
52920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
52921   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52922   Dali::TouchData *arg2 = 0 ;
52923
52924   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52925   arg2 = (Dali::TouchData *)jarg2;
52926   if (!arg2) {
52927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
52928     return ;
52929   }
52930   {
52931     try {
52932       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
52933     } catch (std::out_of_range& e) {
52934       {
52935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52936       };
52937     } catch (std::exception& e) {
52938       {
52939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52940       };
52941     } catch (Dali::DaliException e) {
52942       {
52943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52944       };
52945     } catch (...) {
52946       {
52947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52948       };
52949     }
52950   }
52951
52952 }
52953
52954
52955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
52956   void * jresult ;
52957   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
52958
52959   {
52960     try {
52961       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
52962     } catch (std::out_of_range& e) {
52963       {
52964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52965       };
52966     } catch (std::exception& e) {
52967       {
52968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52969       };
52970     } catch (Dali::DaliException e) {
52971       {
52972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52973       };
52974     } catch (...) {
52975       {
52976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52977       };
52978     }
52979   }
52980
52981   jresult = (void *)result;
52982   return jresult;
52983 }
52984
52985
52986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
52987   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52988
52989   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52990   {
52991     try {
52992       delete arg1;
52993     } catch (std::out_of_range& e) {
52994       {
52995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52996       };
52997     } catch (std::exception& e) {
52998       {
52999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53000       };
53001     } catch (Dali::DaliException e) {
53002       {
53003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53004       };
53005     } catch (...) {
53006       {
53007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53008       };
53009     }
53010   }
53011
53012 }
53013
53014
53015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
53016   unsigned int jresult ;
53017   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53018   bool result;
53019
53020   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53021   {
53022     try {
53023       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53024     } catch (std::out_of_range& e) {
53025       {
53026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53027       };
53028     } catch (std::exception& e) {
53029       {
53030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53031       };
53032     } catch (Dali::DaliException e) {
53033       {
53034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53035       };
53036     } catch (...) {
53037       {
53038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53039       };
53040     }
53041   }
53042
53043   jresult = result;
53044   return jresult;
53045 }
53046
53047
53048 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
53049   unsigned long jresult ;
53050   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53051   std::size_t result;
53052
53053   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53054   {
53055     try {
53056       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53057     } catch (std::out_of_range& e) {
53058       {
53059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53060       };
53061     } catch (std::exception& e) {
53062       {
53063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53064       };
53065     } catch (Dali::DaliException e) {
53066       {
53067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53068       };
53069     } catch (...) {
53070       {
53071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53072       };
53073     }
53074   }
53075
53076   jresult = (unsigned long)result;
53077   return jresult;
53078 }
53079
53080
53081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53082   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53083   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53084
53085   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53086   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53087   {
53088     try {
53089       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53090     } catch (std::out_of_range& e) {
53091       {
53092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53093       };
53094     } catch (std::exception& e) {
53095       {
53096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53097       };
53098     } catch (Dali::DaliException e) {
53099       {
53100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53101       };
53102     } catch (...) {
53103       {
53104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53105       };
53106     }
53107   }
53108
53109 }
53110
53111
53112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53113   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53114   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53115
53116   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53117   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53118   {
53119     try {
53120       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53121     } catch (std::out_of_range& e) {
53122       {
53123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53124       };
53125     } catch (std::exception& e) {
53126       {
53127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53128       };
53129     } catch (Dali::DaliException e) {
53130       {
53131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53132       };
53133     } catch (...) {
53134       {
53135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53136       };
53137     }
53138   }
53139
53140 }
53141
53142
53143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53144   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53145   Dali::WheelEvent *arg2 = 0 ;
53146
53147   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53148   arg2 = (Dali::WheelEvent *)jarg2;
53149   if (!arg2) {
53150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53151     return ;
53152   }
53153   {
53154     try {
53155       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53156     } catch (std::out_of_range& e) {
53157       {
53158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53159       };
53160     } catch (std::exception& e) {
53161       {
53162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53163       };
53164     } catch (Dali::DaliException e) {
53165       {
53166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53167       };
53168     } catch (...) {
53169       {
53170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53171       };
53172     }
53173   }
53174
53175 }
53176
53177
53178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53179   void * jresult ;
53180   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53181
53182   {
53183     try {
53184       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53185     } catch (std::out_of_range& e) {
53186       {
53187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53188       };
53189     } catch (std::exception& e) {
53190       {
53191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53192       };
53193     } catch (Dali::DaliException e) {
53194       {
53195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53196       };
53197     } catch (...) {
53198       {
53199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53200       };
53201     }
53202   }
53203
53204   jresult = (void *)result;
53205   return jresult;
53206 }
53207
53208
53209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53210   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53211
53212   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53213   {
53214     try {
53215       delete arg1;
53216     } catch (std::out_of_range& e) {
53217       {
53218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53219       };
53220     } catch (std::exception& e) {
53221       {
53222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53223       };
53224     } catch (Dali::DaliException e) {
53225       {
53226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53227       };
53228     } catch (...) {
53229       {
53230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53231       };
53232     }
53233   }
53234
53235 }
53236
53237
53238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53239   void * jresult ;
53240   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53241
53242   {
53243     try {
53244       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53245     } catch (std::out_of_range& e) {
53246       {
53247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53248       };
53249     } catch (std::exception& e) {
53250       {
53251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53252       };
53253     } catch (Dali::DaliException e) {
53254       {
53255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53256       };
53257     } catch (...) {
53258       {
53259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53260       };
53261     }
53262   }
53263
53264   jresult = (void *)result;
53265   return jresult;
53266 }
53267
53268
53269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53270   void * jresult ;
53271   Dali::Radian arg1 ;
53272   Dali::Radian arg2 ;
53273   Dali::Radian *argp1 ;
53274   Dali::Radian *argp2 ;
53275   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53276
53277   argp1 = (Dali::Radian *)jarg1;
53278   if (!argp1) {
53279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53280     return 0;
53281   }
53282   arg1 = *argp1;
53283   argp2 = (Dali::Radian *)jarg2;
53284   if (!argp2) {
53285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53286     return 0;
53287   }
53288   arg2 = *argp2;
53289   {
53290     try {
53291       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53292     } catch (std::out_of_range& e) {
53293       {
53294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53295       };
53296     } catch (std::exception& e) {
53297       {
53298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53299       };
53300     } catch (Dali::DaliException e) {
53301       {
53302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53303       };
53304     } catch (...) {
53305       {
53306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53307       };
53308     }
53309   }
53310
53311   jresult = (void *)result;
53312   return jresult;
53313 }
53314
53315
53316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53317   void * jresult ;
53318   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53319   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53320
53321   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53322   if (!arg1) {
53323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53324     return 0;
53325   }
53326   {
53327     try {
53328       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53329     } catch (std::out_of_range& e) {
53330       {
53331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53332       };
53333     } catch (std::exception& e) {
53334       {
53335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53336       };
53337     } catch (Dali::DaliException e) {
53338       {
53339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53340       };
53341     } catch (...) {
53342       {
53343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53344       };
53345     }
53346   }
53347
53348   jresult = (void *)result;
53349   return jresult;
53350 }
53351
53352
53353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53354   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53355   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53356
53357   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53358   arg2 = (Dali::Radian *)jarg2;
53359   if (arg1) (arg1)->first = *arg2;
53360 }
53361
53362
53363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53364   void * jresult ;
53365   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53366   Dali::Radian *result = 0 ;
53367
53368   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53369   result = (Dali::Radian *)& ((arg1)->first);
53370   jresult = (void *)result;
53371   return jresult;
53372 }
53373
53374
53375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53376   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53377   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53378
53379   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53380   arg2 = (Dali::Radian *)jarg2;
53381   if (arg1) (arg1)->second = *arg2;
53382 }
53383
53384
53385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53386   void * jresult ;
53387   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53388   Dali::Radian *result = 0 ;
53389
53390   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53391   result = (Dali::Radian *)& ((arg1)->second);
53392   jresult = (void *)result;
53393   return jresult;
53394 }
53395
53396
53397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53398   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53399
53400   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53401   {
53402     try {
53403       delete arg1;
53404     } catch (std::out_of_range& e) {
53405       {
53406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53407       };
53408     } catch (std::exception& e) {
53409       {
53410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53411       };
53412     } catch (Dali::DaliException e) {
53413       {
53414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53415       };
53416     } catch (...) {
53417       {
53418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53419       };
53420     }
53421   }
53422
53423 }
53424
53425
53426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53427   unsigned int jresult ;
53428   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53429   bool result;
53430
53431   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53432   {
53433     try {
53434       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);
53435     } catch (std::out_of_range& e) {
53436       {
53437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53438       };
53439     } catch (std::exception& e) {
53440       {
53441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53442       };
53443     } catch (Dali::DaliException e) {
53444       {
53445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53446       };
53447     } catch (...) {
53448       {
53449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53450       };
53451     }
53452   }
53453
53454   jresult = result;
53455   return jresult;
53456 }
53457
53458
53459 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53460   unsigned long jresult ;
53461   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53462   std::size_t result;
53463
53464   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53465   {
53466     try {
53467       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);
53468     } catch (std::out_of_range& e) {
53469       {
53470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53471       };
53472     } catch (std::exception& e) {
53473       {
53474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53475       };
53476     } catch (Dali::DaliException e) {
53477       {
53478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53479       };
53480     } catch (...) {
53481       {
53482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53483       };
53484     }
53485   }
53486
53487   jresult = (unsigned long)result;
53488   return jresult;
53489 }
53490
53491
53492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53493   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53494   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53495
53496   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53497   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53498   {
53499     try {
53500       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53501     } catch (std::out_of_range& e) {
53502       {
53503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53504       };
53505     } catch (std::exception& e) {
53506       {
53507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53508       };
53509     } catch (Dali::DaliException e) {
53510       {
53511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53512       };
53513     } catch (...) {
53514       {
53515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53516       };
53517     }
53518   }
53519
53520 }
53521
53522
53523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53524   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53525   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53526
53527   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53528   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53529   {
53530     try {
53531       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53532     } catch (std::out_of_range& e) {
53533       {
53534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53535       };
53536     } catch (std::exception& e) {
53537       {
53538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53539       };
53540     } catch (Dali::DaliException e) {
53541       {
53542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53543       };
53544     } catch (...) {
53545       {
53546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53547       };
53548     }
53549   }
53550
53551 }
53552
53553
53554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53555   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53556   Dali::Actor arg2 ;
53557   Dali::PanGesture *arg3 = 0 ;
53558   Dali::Actor *argp2 ;
53559
53560   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53561   argp2 = (Dali::Actor *)jarg2;
53562   if (!argp2) {
53563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53564     return ;
53565   }
53566   arg2 = *argp2;
53567   arg3 = (Dali::PanGesture *)jarg3;
53568   if (!arg3) {
53569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53570     return ;
53571   }
53572   {
53573     try {
53574       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53575     } catch (std::out_of_range& e) {
53576       {
53577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53578       };
53579     } catch (std::exception& e) {
53580       {
53581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53582       };
53583     } catch (Dali::DaliException e) {
53584       {
53585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53586       };
53587     } catch (...) {
53588       {
53589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53590       };
53591     }
53592   }
53593
53594 }
53595
53596
53597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
53598   void * jresult ;
53599   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53600
53601   {
53602     try {
53603       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53604     } catch (std::out_of_range& e) {
53605       {
53606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53607       };
53608     } catch (std::exception& e) {
53609       {
53610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53611       };
53612     } catch (Dali::DaliException e) {
53613       {
53614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53615       };
53616     } catch (...) {
53617       {
53618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53619       };
53620     }
53621   }
53622
53623   jresult = (void *)result;
53624   return jresult;
53625 }
53626
53627
53628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
53629   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53630
53631   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53632   {
53633     try {
53634       delete arg1;
53635     } catch (std::out_of_range& e) {
53636       {
53637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53638       };
53639     } catch (std::exception& e) {
53640       {
53641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53642       };
53643     } catch (Dali::DaliException e) {
53644       {
53645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53646       };
53647     } catch (...) {
53648       {
53649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53650       };
53651     }
53652   }
53653
53654 }
53655
53656
53657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
53658   unsigned int jresult ;
53659   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53660   bool result;
53661
53662   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53663   {
53664     try {
53665       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);
53666     } catch (std::out_of_range& e) {
53667       {
53668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53669       };
53670     } catch (std::exception& e) {
53671       {
53672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53673       };
53674     } catch (Dali::DaliException e) {
53675       {
53676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53677       };
53678     } catch (...) {
53679       {
53680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53681       };
53682     }
53683   }
53684
53685   jresult = result;
53686   return jresult;
53687 }
53688
53689
53690 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53691   unsigned long jresult ;
53692   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53693   std::size_t result;
53694
53695   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53696   {
53697     try {
53698       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);
53699     } catch (std::out_of_range& e) {
53700       {
53701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53702       };
53703     } catch (std::exception& e) {
53704       {
53705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53706       };
53707     } catch (Dali::DaliException e) {
53708       {
53709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53710       };
53711     } catch (...) {
53712       {
53713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53714       };
53715     }
53716   }
53717
53718   jresult = (unsigned long)result;
53719   return jresult;
53720 }
53721
53722
53723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53724   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53725   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53726
53727   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53728   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53729   {
53730     try {
53731       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53732     } catch (std::out_of_range& e) {
53733       {
53734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53735       };
53736     } catch (std::exception& e) {
53737       {
53738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53739       };
53740     } catch (Dali::DaliException e) {
53741       {
53742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53743       };
53744     } catch (...) {
53745       {
53746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53747       };
53748     }
53749   }
53750
53751 }
53752
53753
53754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53755   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53756   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53757
53758   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53759   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53760   {
53761     try {
53762       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53763     } catch (std::out_of_range& e) {
53764       {
53765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53766       };
53767     } catch (std::exception& e) {
53768       {
53769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53770       };
53771     } catch (Dali::DaliException e) {
53772       {
53773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53774       };
53775     } catch (...) {
53776       {
53777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53778       };
53779     }
53780   }
53781
53782 }
53783
53784
53785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53786   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53787   Dali::Actor arg2 ;
53788   Dali::PinchGesture *arg3 = 0 ;
53789   Dali::Actor *argp2 ;
53790
53791   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53792   argp2 = (Dali::Actor *)jarg2;
53793   if (!argp2) {
53794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53795     return ;
53796   }
53797   arg2 = *argp2;
53798   arg3 = (Dali::PinchGesture *)jarg3;
53799   if (!arg3) {
53800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
53801     return ;
53802   }
53803   {
53804     try {
53805       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
53806     } catch (std::out_of_range& e) {
53807       {
53808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53809       };
53810     } catch (std::exception& e) {
53811       {
53812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53813       };
53814     } catch (Dali::DaliException e) {
53815       {
53816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53817       };
53818     } catch (...) {
53819       {
53820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53821       };
53822     }
53823   }
53824
53825 }
53826
53827
53828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
53829   void * jresult ;
53830   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
53831
53832   {
53833     try {
53834       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
53835     } catch (std::out_of_range& e) {
53836       {
53837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53838       };
53839     } catch (std::exception& e) {
53840       {
53841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53842       };
53843     } catch (Dali::DaliException e) {
53844       {
53845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53846       };
53847     } catch (...) {
53848       {
53849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53850       };
53851     }
53852   }
53853
53854   jresult = (void *)result;
53855   return jresult;
53856 }
53857
53858
53859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
53860   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53861
53862   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53863   {
53864     try {
53865       delete arg1;
53866     } catch (std::out_of_range& e) {
53867       {
53868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53869       };
53870     } catch (std::exception& e) {
53871       {
53872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53873       };
53874     } catch (Dali::DaliException e) {
53875       {
53876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53877       };
53878     } catch (...) {
53879       {
53880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53881       };
53882     }
53883   }
53884
53885 }
53886
53887
53888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
53889   unsigned int jresult ;
53890   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53891   bool result;
53892
53893   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53894   {
53895     try {
53896       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);
53897     } catch (std::out_of_range& e) {
53898       {
53899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53900       };
53901     } catch (std::exception& e) {
53902       {
53903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53904       };
53905     } catch (Dali::DaliException e) {
53906       {
53907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53908       };
53909     } catch (...) {
53910       {
53911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53912       };
53913     }
53914   }
53915
53916   jresult = result;
53917   return jresult;
53918 }
53919
53920
53921 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53922   unsigned long jresult ;
53923   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53924   std::size_t result;
53925
53926   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53927   {
53928     try {
53929       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);
53930     } catch (std::out_of_range& e) {
53931       {
53932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53933       };
53934     } catch (std::exception& e) {
53935       {
53936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53937       };
53938     } catch (Dali::DaliException e) {
53939       {
53940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53941       };
53942     } catch (...) {
53943       {
53944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53945       };
53946     }
53947   }
53948
53949   jresult = (unsigned long)result;
53950   return jresult;
53951 }
53952
53953
53954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53955   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53956   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53957
53958   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53959   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53960   {
53961     try {
53962       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53963     } catch (std::out_of_range& e) {
53964       {
53965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53966       };
53967     } catch (std::exception& e) {
53968       {
53969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53970       };
53971     } catch (Dali::DaliException e) {
53972       {
53973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53974       };
53975     } catch (...) {
53976       {
53977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53978       };
53979     }
53980   }
53981
53982 }
53983
53984
53985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53986   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53987   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53988
53989   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53990   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53991   {
53992     try {
53993       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53994     } catch (std::out_of_range& e) {
53995       {
53996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53997       };
53998     } catch (std::exception& e) {
53999       {
54000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54001       };
54002     } catch (Dali::DaliException e) {
54003       {
54004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54005       };
54006     } catch (...) {
54007       {
54008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54009       };
54010     }
54011   }
54012
54013 }
54014
54015
54016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54017   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54018   Dali::Actor arg2 ;
54019   Dali::TapGesture *arg3 = 0 ;
54020   Dali::Actor *argp2 ;
54021
54022   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54023   argp2 = (Dali::Actor *)jarg2;
54024   if (!argp2) {
54025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54026     return ;
54027   }
54028   arg2 = *argp2;
54029   arg3 = (Dali::TapGesture *)jarg3;
54030   if (!arg3) {
54031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
54032     return ;
54033   }
54034   {
54035     try {
54036       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
54037     } catch (std::out_of_range& e) {
54038       {
54039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54040       };
54041     } catch (std::exception& e) {
54042       {
54043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54044       };
54045     } catch (Dali::DaliException e) {
54046       {
54047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54048       };
54049     } catch (...) {
54050       {
54051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54052       };
54053     }
54054   }
54055
54056 }
54057
54058
54059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54060   void * jresult ;
54061   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54062
54063   {
54064     try {
54065       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54066     } catch (std::out_of_range& e) {
54067       {
54068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54069       };
54070     } catch (std::exception& e) {
54071       {
54072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54073       };
54074     } catch (Dali::DaliException e) {
54075       {
54076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54077       };
54078     } catch (...) {
54079       {
54080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54081       };
54082     }
54083   }
54084
54085   jresult = (void *)result;
54086   return jresult;
54087 }
54088
54089
54090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54091   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54092
54093   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54094   {
54095     try {
54096       delete arg1;
54097     } catch (std::out_of_range& e) {
54098       {
54099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54100       };
54101     } catch (std::exception& e) {
54102       {
54103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54104       };
54105     } catch (Dali::DaliException e) {
54106       {
54107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54108       };
54109     } catch (...) {
54110       {
54111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54112       };
54113     }
54114   }
54115
54116 }
54117
54118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54119   unsigned int jresult ;
54120   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54121   bool result = false;
54122
54123   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54124   {
54125     try {
54126       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);
54127     } catch (std::out_of_range& e) {
54128       {
54129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54130       };
54131     } catch (std::exception& e) {
54132       {
54133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54134       };
54135     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54136   }
54137   jresult = result;
54138   return jresult;
54139 }
54140
54141 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54142   unsigned long jresult ;
54143   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54144   std::size_t result = 0;
54145
54146   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54147   {
54148     try {
54149       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);
54150     } catch (std::out_of_range& e) {
54151       {
54152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54153       };
54154     } catch (std::exception& e) {
54155       {
54156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54157       };
54158     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54159   }
54160   jresult = (unsigned long)result;
54161   return jresult;
54162 }
54163
54164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54165   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54166   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54167
54168   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54169   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54170   {
54171     try {
54172       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54173     } catch (std::out_of_range& e) {
54174       {
54175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54176       };
54177     } catch (std::exception& e) {
54178       {
54179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54180       };
54181     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54182   }
54183 }
54184
54185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54186   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54187   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54188
54189   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54190   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54191   {
54192     try {
54193       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54194     } catch (std::out_of_range& e) {
54195       {
54196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54197       };
54198     } catch (std::exception& e) {
54199       {
54200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54201       };
54202     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54203   }
54204 }
54205
54206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54207   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54208   Dali::Actor arg2 ;
54209   //bool arg3 ;
54210   Dali::LayoutDirection::Type arg4 ;
54211   Dali::Actor *argp2 ;
54212
54213   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54214   argp2 = (Dali::Actor *)jarg2;
54215   if (!argp2) {
54216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54217     return ;
54218   }
54219   arg2 = *argp2;
54220   //arg3 = jarg3 ? true : false;
54221   arg4 = (Dali::LayoutDirection::Type)jarg4;
54222   {
54223     try {
54224       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54225     } catch (std::out_of_range& e) {
54226       {
54227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54228       };
54229     } catch (std::exception& e) {
54230       {
54231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54232       };
54233     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54234   }
54235 }
54236
54237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54238   void * jresult ;
54239   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54240
54241   {
54242     try {
54243       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54244     } catch (std::out_of_range& e) {
54245       {
54246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54247       };
54248     } catch (std::exception& e) {
54249       {
54250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54251       };
54252     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54253   }
54254   jresult = (void *)result;
54255   return jresult;
54256 }
54257
54258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54259   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54260
54261   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54262   {
54263     try {
54264       delete arg1;
54265     } catch (std::out_of_range& e) {
54266       {
54267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54268       };
54269     } catch (std::exception& e) {
54270       {
54271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54272       };
54273     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54274   }
54275 }
54276
54277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54278   unsigned int jresult ;
54279   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54280   bool result;
54281
54282   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54283   {
54284     try {
54285       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);
54286     } catch (std::out_of_range& e) {
54287       {
54288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54289       };
54290     } catch (std::exception& e) {
54291       {
54292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54293       };
54294     } catch (Dali::DaliException e) {
54295       {
54296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54297       };
54298     } catch (...) {
54299       {
54300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54301       };
54302     }
54303   }
54304
54305   jresult = result;
54306   return jresult;
54307 }
54308
54309
54310 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54311   unsigned long jresult ;
54312   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54313   std::size_t result;
54314
54315   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54316   {
54317     try {
54318       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);
54319     } catch (std::out_of_range& e) {
54320       {
54321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54322       };
54323     } catch (std::exception& e) {
54324       {
54325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54326       };
54327     } catch (Dali::DaliException e) {
54328       {
54329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54330       };
54331     } catch (...) {
54332       {
54333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54334       };
54335     }
54336   }
54337
54338   jresult = (unsigned long)result;
54339   return jresult;
54340 }
54341
54342
54343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54344   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54345   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54346
54347   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54348   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54349   {
54350     try {
54351       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54352     } catch (std::out_of_range& e) {
54353       {
54354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54355       };
54356     } catch (std::exception& e) {
54357       {
54358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54359       };
54360     } catch (Dali::DaliException e) {
54361       {
54362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54363       };
54364     } catch (...) {
54365       {
54366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54367       };
54368     }
54369   }
54370
54371 }
54372
54373
54374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54375   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54376   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54377
54378   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54379   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54380   {
54381     try {
54382       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54383     } catch (std::out_of_range& e) {
54384       {
54385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54386       };
54387     } catch (std::exception& e) {
54388       {
54389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54390       };
54391     } catch (Dali::DaliException e) {
54392       {
54393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54394       };
54395     } catch (...) {
54396       {
54397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54398       };
54399     }
54400   }
54401
54402 }
54403
54404
54405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54406   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54407   Dali::Actor arg2 ;
54408   bool arg3 ;
54409   Dali::DevelActor::VisibilityChange::Type arg4 ;
54410   Dali::Actor *argp2 ;
54411
54412   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54413   argp2 = (Dali::Actor *)jarg2;
54414   if (!argp2) {
54415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54416     return ;
54417   }
54418   arg2 = *argp2;
54419   arg3 = jarg3 ? true : false;
54420   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54421   {
54422     try {
54423       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54424     } catch (std::out_of_range& e) {
54425       {
54426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54427       };
54428     } catch (std::exception& e) {
54429       {
54430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54431       };
54432     } catch (Dali::DaliException e) {
54433       {
54434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54435       };
54436     } catch (...) {
54437       {
54438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54439       };
54440     }
54441   }
54442
54443 }
54444
54445
54446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54447   void * jresult ;
54448   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54449
54450   {
54451     try {
54452       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54453     } catch (std::out_of_range& e) {
54454       {
54455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54456       };
54457     } catch (std::exception& e) {
54458       {
54459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54460       };
54461     } catch (Dali::DaliException e) {
54462       {
54463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54464       };
54465     } catch (...) {
54466       {
54467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54468       };
54469     }
54470   }
54471
54472   jresult = (void *)result;
54473   return jresult;
54474 }
54475
54476
54477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54478   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54479
54480   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54481   {
54482     try {
54483       delete arg1;
54484     } catch (std::out_of_range& e) {
54485       {
54486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54487       };
54488     } catch (std::exception& e) {
54489       {
54490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54491       };
54492     } catch (Dali::DaliException e) {
54493       {
54494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54495       };
54496     } catch (...) {
54497       {
54498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54499       };
54500     }
54501   }
54502
54503 }
54504
54505
54506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54507   void * jresult ;
54508   Dali::Timer *result = 0 ;
54509
54510   {
54511     try {
54512       result = (Dali::Timer *)new Dali::Timer();
54513     } catch (std::out_of_range& e) {
54514       {
54515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54516       };
54517     } catch (std::exception& e) {
54518       {
54519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54520       };
54521     } catch (Dali::DaliException e) {
54522       {
54523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54524       };
54525     } catch (...) {
54526       {
54527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54528       };
54529     }
54530   }
54531
54532   jresult = (void *)result;
54533   return jresult;
54534 }
54535
54536
54537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54538   void * jresult ;
54539   unsigned int arg1 ;
54540   Dali::Timer result;
54541
54542   arg1 = (unsigned int)jarg1;
54543   {
54544     try {
54545       result = Dali::Timer::New(arg1);
54546     } catch (std::out_of_range& e) {
54547       {
54548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54549       };
54550     } catch (std::exception& e) {
54551       {
54552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54553       };
54554     } catch (Dali::DaliException e) {
54555       {
54556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54557       };
54558     } catch (...) {
54559       {
54560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54561       };
54562     }
54563   }
54564
54565   jresult = new Dali::Timer((const Dali::Timer &)result);
54566   return jresult;
54567 }
54568
54569
54570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
54571   void * jresult ;
54572   Dali::Timer *arg1 = 0 ;
54573   Dali::Timer *result = 0 ;
54574
54575   arg1 = (Dali::Timer *)jarg1;
54576   if (!arg1) {
54577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54578     return 0;
54579   }
54580   {
54581     try {
54582       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
54583     } catch (std::out_of_range& e) {
54584       {
54585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54586       };
54587     } catch (std::exception& e) {
54588       {
54589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54590       };
54591     } catch (Dali::DaliException e) {
54592       {
54593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54594       };
54595     } catch (...) {
54596       {
54597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54598       };
54599     }
54600   }
54601
54602   jresult = (void *)result;
54603   return jresult;
54604 }
54605
54606
54607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
54608   void * jresult ;
54609   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54610   Dali::Timer *arg2 = 0 ;
54611   Dali::Timer *result = 0 ;
54612
54613   arg1 = (Dali::Timer *)jarg1;
54614   arg2 = (Dali::Timer *)jarg2;
54615   if (!arg2) {
54616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54617     return 0;
54618   }
54619   {
54620     try {
54621       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
54622     } catch (std::out_of_range& e) {
54623       {
54624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54625       };
54626     } catch (std::exception& e) {
54627       {
54628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54629       };
54630     } catch (Dali::DaliException e) {
54631       {
54632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54633       };
54634     } catch (...) {
54635       {
54636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54637       };
54638     }
54639   }
54640
54641   jresult = (void *)result;
54642   return jresult;
54643 }
54644
54645
54646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
54647   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54648
54649   arg1 = (Dali::Timer *)jarg1;
54650   {
54651     try {
54652       delete arg1;
54653     } catch (std::out_of_range& e) {
54654       {
54655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54656       };
54657     } catch (std::exception& e) {
54658       {
54659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54660       };
54661     } catch (Dali::DaliException e) {
54662       {
54663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54664       };
54665     } catch (...) {
54666       {
54667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54668       };
54669     }
54670   }
54671
54672 }
54673
54674
54675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
54676   void * jresult ;
54677   Dali::BaseHandle arg1 ;
54678   Dali::BaseHandle *argp1 ;
54679   Dali::Timer result;
54680
54681   argp1 = (Dali::BaseHandle *)jarg1;
54682   if (!argp1) {
54683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54684     return 0;
54685   }
54686   arg1 = *argp1;
54687   {
54688     try {
54689       result = Dali::Timer::DownCast(arg1);
54690     } catch (std::out_of_range& e) {
54691       {
54692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54693       };
54694     } catch (std::exception& e) {
54695       {
54696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54697       };
54698     } catch (Dali::DaliException e) {
54699       {
54700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54701       };
54702     } catch (...) {
54703       {
54704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54705       };
54706     }
54707   }
54708
54709   jresult = new Dali::Timer((const Dali::Timer &)result);
54710   return jresult;
54711 }
54712
54713
54714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
54715   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54716
54717   arg1 = (Dali::Timer *)jarg1;
54718   {
54719     try {
54720       (arg1)->Start();
54721     } catch (std::out_of_range& e) {
54722       {
54723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54724       };
54725     } catch (std::exception& e) {
54726       {
54727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54728       };
54729     } catch (Dali::DaliException e) {
54730       {
54731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54732       };
54733     } catch (...) {
54734       {
54735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54736       };
54737     }
54738   }
54739
54740 }
54741
54742
54743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
54744   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54745
54746   arg1 = (Dali::Timer *)jarg1;
54747   {
54748     try {
54749       (arg1)->Stop();
54750     } catch (std::out_of_range& e) {
54751       {
54752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54753       };
54754     } catch (std::exception& e) {
54755       {
54756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54757       };
54758     } catch (Dali::DaliException e) {
54759       {
54760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54761       };
54762     } catch (...) {
54763       {
54764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54765       };
54766     }
54767   }
54768
54769 }
54770
54771
54772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
54773   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54774   unsigned int arg2 ;
54775
54776   arg1 = (Dali::Timer *)jarg1;
54777   arg2 = (unsigned int)jarg2;
54778   {
54779     try {
54780       (arg1)->SetInterval(arg2);
54781     } catch (std::out_of_range& e) {
54782       {
54783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54784       };
54785     } catch (std::exception& e) {
54786       {
54787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54788       };
54789     } catch (Dali::DaliException e) {
54790       {
54791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54792       };
54793     } catch (...) {
54794       {
54795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54796       };
54797     }
54798   }
54799
54800 }
54801
54802
54803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
54804   unsigned int jresult ;
54805   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54806   unsigned int result;
54807
54808   arg1 = (Dali::Timer *)jarg1;
54809   {
54810     try {
54811       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
54812     } catch (std::out_of_range& e) {
54813       {
54814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54815       };
54816     } catch (std::exception& e) {
54817       {
54818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54819       };
54820     } catch (Dali::DaliException e) {
54821       {
54822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54823       };
54824     } catch (...) {
54825       {
54826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54827       };
54828     }
54829   }
54830
54831   jresult = result;
54832   return jresult;
54833 }
54834
54835
54836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
54837   unsigned int jresult ;
54838   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54839   bool result;
54840
54841   arg1 = (Dali::Timer *)jarg1;
54842   {
54843     try {
54844       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
54845     } catch (std::out_of_range& e) {
54846       {
54847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54848       };
54849     } catch (std::exception& e) {
54850       {
54851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54852       };
54853     } catch (Dali::DaliException e) {
54854       {
54855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54856       };
54857     } catch (...) {
54858       {
54859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54860       };
54861     }
54862   }
54863
54864   jresult = result;
54865   return jresult;
54866 }
54867
54868
54869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
54870   void * jresult ;
54871   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54872   Dali::Timer::TimerSignalType *result = 0 ;
54873
54874   arg1 = (Dali::Timer *)jarg1;
54875   {
54876     try {
54877       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
54878     } catch (std::out_of_range& e) {
54879       {
54880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54881       };
54882     } catch (std::exception& e) {
54883       {
54884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54885       };
54886     } catch (Dali::DaliException e) {
54887       {
54888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54889       };
54890     } catch (...) {
54891       {
54892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54893       };
54894     }
54895   }
54896
54897   jresult = (void *)result;
54898   return jresult;
54899 }
54900
54901
54902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
54903   unsigned int jresult ;
54904   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54905   bool result;
54906
54907   arg1 = (Dali::Signal< bool () > *)jarg1;
54908   {
54909     try {
54910       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
54911     } catch (std::out_of_range& e) {
54912       {
54913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54914       };
54915     } catch (std::exception& e) {
54916       {
54917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54918       };
54919     } catch (Dali::DaliException e) {
54920       {
54921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54922       };
54923     } catch (...) {
54924       {
54925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54926       };
54927     }
54928   }
54929
54930   jresult = result;
54931   return jresult;
54932 }
54933
54934
54935 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
54936   unsigned long jresult ;
54937   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54938   std::size_t result;
54939
54940   arg1 = (Dali::Signal< bool () > *)jarg1;
54941   {
54942     try {
54943       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
54944     } catch (std::out_of_range& e) {
54945       {
54946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54947       };
54948     } catch (std::exception& e) {
54949       {
54950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54951       };
54952     } catch (Dali::DaliException e) {
54953       {
54954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54955       };
54956     } catch (...) {
54957       {
54958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54959       };
54960     }
54961   }
54962
54963   jresult = (unsigned long)result;
54964   return jresult;
54965 }
54966
54967
54968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
54969   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54970   bool (*arg2)() = (bool (*)()) 0 ;
54971
54972   arg1 = (Dali::Signal< bool () > *)jarg1;
54973   arg2 = (bool (*)())jarg2;
54974   {
54975     try {
54976       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
54977     } catch (std::out_of_range& e) {
54978       {
54979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54980       };
54981     } catch (std::exception& e) {
54982       {
54983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54984       };
54985     } catch (Dali::DaliException e) {
54986       {
54987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54988       };
54989     } catch (...) {
54990       {
54991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54992       };
54993     }
54994   }
54995
54996 }
54997
54998
54999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55000   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55001   bool (*arg2)() = (bool (*)()) 0 ;
55002
55003   arg1 = (Dali::Signal< bool () > *)jarg1;
55004   arg2 = (bool (*)())jarg2;
55005   {
55006     try {
55007       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55008     } catch (std::out_of_range& e) {
55009       {
55010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55011       };
55012     } catch (std::exception& e) {
55013       {
55014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55015       };
55016     } catch (Dali::DaliException e) {
55017       {
55018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55019       };
55020     } catch (...) {
55021       {
55022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55023       };
55024     }
55025   }
55026
55027 }
55028
55029
55030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55031   unsigned int jresult ;
55032   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55033   bool result;
55034
55035   arg1 = (Dali::Signal< bool () > *)jarg1;
55036   {
55037     try {
55038       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55039     } catch (std::out_of_range& e) {
55040       {
55041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55042       };
55043     } catch (std::exception& e) {
55044       {
55045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55046       };
55047     } catch (Dali::DaliException e) {
55048       {
55049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55050       };
55051     } catch (...) {
55052       {
55053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55054       };
55055     }
55056   }
55057
55058   jresult = result;
55059   return jresult;
55060 }
55061
55062
55063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55064   void * jresult ;
55065   Dali::Signal< bool () > *result = 0 ;
55066
55067   {
55068     try {
55069       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55070     } catch (std::out_of_range& e) {
55071       {
55072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55073       };
55074     } catch (std::exception& e) {
55075       {
55076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55077       };
55078     } catch (Dali::DaliException e) {
55079       {
55080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55081       };
55082     } catch (...) {
55083       {
55084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55085       };
55086     }
55087   }
55088
55089   jresult = (void *)result;
55090   return jresult;
55091 }
55092
55093
55094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55095   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55096
55097   arg1 = (Dali::Signal< bool () > *)jarg1;
55098   {
55099     try {
55100       delete arg1;
55101     } catch (std::out_of_range& e) {
55102       {
55103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55104       };
55105     } catch (std::exception& e) {
55106       {
55107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55108       };
55109     } catch (Dali::DaliException e) {
55110       {
55111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55112       };
55113     } catch (...) {
55114       {
55115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55116       };
55117     }
55118   }
55119
55120 }
55121
55122
55123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55124   int jresult ;
55125   int result;
55126
55127   {
55128     try {
55129       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55130     } catch (std::out_of_range& e) {
55131       {
55132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55133       };
55134     } catch (std::exception& e) {
55135       {
55136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55137       };
55138     } catch (Dali::DaliException e) {
55139       {
55140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55141       };
55142     } catch (...) {
55143       {
55144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55145       };
55146     }
55147   }
55148
55149   jresult = (int)result;
55150   return jresult;
55151 }
55152
55153
55154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55155   int jresult ;
55156   int result;
55157
55158   {
55159     try {
55160       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55161     } catch (std::out_of_range& e) {
55162       {
55163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55164       };
55165     } catch (std::exception& e) {
55166       {
55167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55168       };
55169     } catch (Dali::DaliException e) {
55170       {
55171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55172       };
55173     } catch (...) {
55174       {
55175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55176       };
55177     }
55178   }
55179
55180   jresult = (int)result;
55181   return jresult;
55182 }
55183
55184
55185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55186   int jresult ;
55187   int result;
55188
55189   {
55190     try {
55191       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55192     } catch (std::out_of_range& e) {
55193       {
55194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55195       };
55196     } catch (std::exception& e) {
55197       {
55198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55199       };
55200     } catch (Dali::DaliException e) {
55201       {
55202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55203       };
55204     } catch (...) {
55205       {
55206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55207       };
55208     }
55209   }
55210
55211   jresult = (int)result;
55212   return jresult;
55213 }
55214
55215
55216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55217   int jresult ;
55218   int result;
55219
55220   {
55221     try {
55222       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55223     } catch (std::out_of_range& e) {
55224       {
55225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55226       };
55227     } catch (std::exception& e) {
55228       {
55229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55230       };
55231     } catch (Dali::DaliException e) {
55232       {
55233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55234       };
55235     } catch (...) {
55236       {
55237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55238       };
55239     }
55240   }
55241
55242   jresult = (int)result;
55243   return jresult;
55244 }
55245
55246
55247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55248   int jresult ;
55249   int result;
55250
55251   {
55252     try {
55253       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55254     } catch (std::out_of_range& e) {
55255       {
55256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55257       };
55258     } catch (std::exception& e) {
55259       {
55260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55261       };
55262     } catch (Dali::DaliException e) {
55263       {
55264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55265       };
55266     } catch (...) {
55267       {
55268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55269       };
55270     }
55271   }
55272
55273   jresult = (int)result;
55274   return jresult;
55275 }
55276
55277
55278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55279   int jresult ;
55280   int result;
55281
55282   {
55283     try {
55284       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55285     } catch (std::out_of_range& e) {
55286       {
55287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55288       };
55289     } catch (std::exception& e) {
55290       {
55291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55292       };
55293     } catch (Dali::DaliException e) {
55294       {
55295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55296       };
55297     } catch (...) {
55298       {
55299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55300       };
55301     }
55302   }
55303
55304   jresult = (int)result;
55305   return jresult;
55306 }
55307
55308
55309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55310   int jresult ;
55311   int result;
55312
55313   {
55314     try {
55315       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55316     } catch (std::out_of_range& e) {
55317       {
55318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55319       };
55320     } catch (std::exception& e) {
55321       {
55322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55323       };
55324     } catch (Dali::DaliException e) {
55325       {
55326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55327       };
55328     } catch (...) {
55329       {
55330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55331       };
55332     }
55333   }
55334
55335   jresult = (int)result;
55336   return jresult;
55337 }
55338
55339
55340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55341   int jresult ;
55342   int result;
55343
55344   {
55345     try {
55346       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55347     } catch (std::out_of_range& e) {
55348       {
55349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55350       };
55351     } catch (std::exception& e) {
55352       {
55353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55354       };
55355     } catch (Dali::DaliException e) {
55356       {
55357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55358       };
55359     } catch (...) {
55360       {
55361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55362       };
55363     }
55364   }
55365
55366   jresult = (int)result;
55367   return jresult;
55368 }
55369
55370
55371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55372   int jresult ;
55373   int result;
55374
55375   {
55376     try {
55377       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55378     } catch (std::out_of_range& e) {
55379       {
55380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55381       };
55382     } catch (std::exception& e) {
55383       {
55384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55385       };
55386     } catch (Dali::DaliException e) {
55387       {
55388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55389       };
55390     } catch (...) {
55391       {
55392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55393       };
55394     }
55395   }
55396
55397   jresult = (int)result;
55398   return jresult;
55399 }
55400
55401
55402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55403   int jresult ;
55404   int result;
55405
55406   {
55407     try {
55408       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55409     } catch (std::out_of_range& e) {
55410       {
55411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55412       };
55413     } catch (std::exception& e) {
55414       {
55415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55416       };
55417     } catch (Dali::DaliException e) {
55418       {
55419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55420       };
55421     } catch (...) {
55422       {
55423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55424       };
55425     }
55426   }
55427
55428   jresult = (int)result;
55429   return jresult;
55430 }
55431
55432
55433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55434   int jresult ;
55435   int result;
55436
55437   {
55438     try {
55439       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55440     } catch (std::out_of_range& e) {
55441       {
55442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55443       };
55444     } catch (std::exception& e) {
55445       {
55446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55447       };
55448     } catch (Dali::DaliException e) {
55449       {
55450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55451       };
55452     } catch (...) {
55453       {
55454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55455       };
55456     }
55457   }
55458
55459   jresult = (int)result;
55460   return jresult;
55461 }
55462
55463
55464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55465   int jresult ;
55466   int result;
55467
55468   {
55469     try {
55470       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55471     } catch (std::out_of_range& e) {
55472       {
55473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55474       };
55475     } catch (std::exception& e) {
55476       {
55477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55478       };
55479     } catch (Dali::DaliException e) {
55480       {
55481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55482       };
55483     } catch (...) {
55484       {
55485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55486       };
55487     }
55488   }
55489
55490   jresult = (int)result;
55491   return jresult;
55492 }
55493
55494
55495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55496   int jresult ;
55497   int result;
55498
55499   {
55500     try {
55501       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55502     } catch (std::out_of_range& e) {
55503       {
55504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55505       };
55506     } catch (std::exception& e) {
55507       {
55508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55509       };
55510     } catch (Dali::DaliException e) {
55511       {
55512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55513       };
55514     } catch (...) {
55515       {
55516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55517       };
55518     }
55519   }
55520
55521   jresult = (int)result;
55522   return jresult;
55523 }
55524
55525
55526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55527   int jresult ;
55528   int result;
55529
55530   {
55531     try {
55532       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55533     } catch (std::out_of_range& e) {
55534       {
55535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55536       };
55537     } catch (std::exception& e) {
55538       {
55539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55540       };
55541     } catch (Dali::DaliException e) {
55542       {
55543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55544       };
55545     } catch (...) {
55546       {
55547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55548       };
55549     }
55550   }
55551
55552   jresult = (int)result;
55553   return jresult;
55554 }
55555
55556
55557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55558   int jresult ;
55559   int result;
55560
55561   {
55562     try {
55563       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55564     } catch (std::out_of_range& e) {
55565       {
55566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55567       };
55568     } catch (std::exception& e) {
55569       {
55570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55571       };
55572     } catch (Dali::DaliException e) {
55573       {
55574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55575       };
55576     } catch (...) {
55577       {
55578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55579       };
55580     }
55581   }
55582
55583   jresult = (int)result;
55584   return jresult;
55585 }
55586
55587
55588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55589   int jresult ;
55590   int result;
55591
55592   {
55593     try {
55594       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55595     } catch (std::out_of_range& e) {
55596       {
55597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55598       };
55599     } catch (std::exception& e) {
55600       {
55601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55602       };
55603     } catch (Dali::DaliException e) {
55604       {
55605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55606       };
55607     } catch (...) {
55608       {
55609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55610       };
55611     }
55612   }
55613
55614   jresult = (int)result;
55615   return jresult;
55616 }
55617
55618
55619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55620   int jresult ;
55621   int result;
55622
55623   {
55624     try {
55625       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
55626     } catch (std::out_of_range& e) {
55627       {
55628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55629       };
55630     } catch (std::exception& e) {
55631       {
55632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55633       };
55634     } catch (Dali::DaliException e) {
55635       {
55636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55637       };
55638     } catch (...) {
55639       {
55640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55641       };
55642     }
55643   }
55644
55645   jresult = (int)result;
55646   return jresult;
55647 }
55648
55649
55650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
55651   int jresult ;
55652   int result;
55653
55654   {
55655     try {
55656       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
55657     } catch (std::out_of_range& e) {
55658       {
55659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55660       };
55661     } catch (std::exception& e) {
55662       {
55663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55664       };
55665     } catch (Dali::DaliException e) {
55666       {
55667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55668       };
55669     } catch (...) {
55670       {
55671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55672       };
55673     }
55674   }
55675
55676   jresult = (int)result;
55677   return jresult;
55678 }
55679
55680
55681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
55682   int jresult ;
55683   int result;
55684
55685   {
55686     try {
55687       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
55688     } catch (std::out_of_range& e) {
55689       {
55690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55691       };
55692     } catch (std::exception& e) {
55693       {
55694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55695       };
55696     } catch (Dali::DaliException e) {
55697       {
55698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55699       };
55700     } catch (...) {
55701       {
55702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55703       };
55704     }
55705   }
55706
55707   jresult = (int)result;
55708   return jresult;
55709 }
55710
55711
55712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
55713   int jresult ;
55714   int result;
55715
55716   {
55717     try {
55718       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
55719     } catch (std::out_of_range& e) {
55720       {
55721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55722       };
55723     } catch (std::exception& e) {
55724       {
55725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55726       };
55727     } catch (Dali::DaliException e) {
55728       {
55729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55730       };
55731     } catch (...) {
55732       {
55733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55734       };
55735     }
55736   }
55737
55738   jresult = (int)result;
55739   return jresult;
55740 }
55741
55742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
55743   int jresult ;
55744   int result;
55745
55746   {
55747     try {
55748       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
55749     } catch (std::out_of_range& e) {
55750       {
55751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55752       };
55753     } catch (std::exception& e) {
55754       {
55755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55756       };
55757     } catch (Dali::DaliException e) {
55758       {
55759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55760       };
55761     } catch (...) {
55762       {
55763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55764       };
55765     }
55766   }
55767
55768   jresult = (int)result;
55769   return jresult;
55770 }
55771
55772
55773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
55774   int jresult ;
55775   int result;
55776   {
55777     try
55778     {
55779       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
55780     } catch (std::out_of_range& e) {
55781       {
55782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55783       };
55784     } catch (std::exception& e) {
55785       {
55786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55787       };
55788     } catch (Dali::DaliException e) {
55789       {
55790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55791       };
55792     } catch (...) {
55793       {
55794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55795       };
55796     }
55797   }
55798
55799   jresult = (int)result;
55800   return jresult;
55801 }
55802
55803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
55804   int jresult ;
55805   int result;
55806   {
55807     try
55808     {
55809       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
55810     } catch (std::out_of_range& e) {
55811       {
55812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55813       };
55814     } catch (std::exception& e) {
55815       {
55816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55817       };
55818     } catch (Dali::DaliException e) {
55819       {
55820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55821       };
55822     } catch (...) {
55823       {
55824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55825       };
55826     }
55827   }
55828
55829   jresult = (int)result;
55830   return jresult;
55831 }
55832
55833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
55834   int jresult ;
55835   int result;
55836   {
55837     try
55838     {
55839       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
55840     } catch (std::out_of_range& e) {
55841       {
55842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55843       };
55844     } catch (std::exception& e) {
55845       {
55846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55847       };
55848     } catch (Dali::DaliException e) {
55849       {
55850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55851       };
55852     } catch (...) {
55853       {
55854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55855       };
55856     }
55857   }
55858
55859   jresult = (int)result;
55860   return jresult;
55861 }
55862
55863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
55864   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
55865 }
55866
55867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
55868   int jresult ;
55869   int result;
55870   {
55871     try
55872     {
55873       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
55874     } catch (std::out_of_range& e) {
55875       {
55876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55877       };
55878     } catch (std::exception& e) {
55879       {
55880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55881       };
55882     } catch (Dali::DaliException e) {
55883       {
55884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55885       };
55886     } catch (...) {
55887       {
55888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55889       };
55890     }
55891   }
55892
55893   jresult = (int)result;
55894   return jresult;
55895 }
55896
55897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
55898   int jresult ;
55899   int result;
55900   {
55901     try
55902     {
55903       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
55904     } catch (std::out_of_range& e) {
55905       {
55906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55907       };
55908     } catch (std::exception& e) {
55909       {
55910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55911       };
55912     } catch (Dali::DaliException e) {
55913       {
55914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55915       };
55916     } catch (...) {
55917       {
55918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55919       };
55920     }
55921   }
55922
55923   jresult = (int)result;
55924   return jresult;
55925 }
55926
55927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
55928   int jresult ;
55929   int result;
55930
55931   {
55932     try {
55933       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
55934     } catch (std::out_of_range& e) {
55935       {
55936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55937       };
55938     } catch (std::exception& e) {
55939       {
55940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55941       };
55942     } catch (Dali::DaliException e) {
55943       {
55944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55945       };
55946     } catch (...) {
55947       {
55948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55949       };
55950     }
55951   }
55952
55953   jresult = (int)result;
55954   return jresult;
55955 }
55956
55957
55958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
55959   int jresult ;
55960   int result;
55961
55962   {
55963     try {
55964       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
55965     } catch (std::out_of_range& e) {
55966       {
55967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55968       };
55969     } catch (std::exception& e) {
55970       {
55971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55972       };
55973     } catch (Dali::DaliException e) {
55974       {
55975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55976       };
55977     } catch (...) {
55978       {
55979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55980       };
55981     }
55982   }
55983
55984   jresult = (int)result;
55985   return jresult;
55986 }
55987
55988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
55989   int jresult ;
55990   int result;
55991   {
55992     try
55993     {
55994       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
55995     } catch (std::out_of_range& e) {
55996       {
55997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55998       };
55999     } catch (std::exception& e) {
56000       {
56001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56002       };
56003     } catch (...) {
56004       {
56005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56006       };
56007     }
56008   }
56009   jresult = (int)result;
56010   return jresult;
56011 }
56012
56013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
56014   int jresult ;
56015   int result;
56016   {
56017     try
56018     {
56019       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
56020     } catch (std::out_of_range& e) {
56021       {
56022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56023       };
56024     } catch (std::exception& e) {
56025       {
56026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56027       };
56028     } catch (...) {
56029       {
56030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56031       };
56032     }
56033   }
56034   jresult = (int)result;
56035   return jresult;
56036 }
56037
56038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
56039   int jresult ;
56040   int result;
56041   {
56042     try
56043     {
56044       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
56045     } catch (std::out_of_range& e) {
56046       {
56047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56048       };
56049     } catch (std::exception& e) {
56050       {
56051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56052       };
56053     } catch (...) {
56054       {
56055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56056       };
56057     }
56058   }
56059   jresult = (int)result;
56060   return jresult;
56061 }
56062
56063
56064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56065   int jresult ;
56066   int result;
56067   {
56068     try
56069     {
56070       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
56071     } catch (std::out_of_range& e) {
56072       {
56073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56074       };
56075     } catch (std::exception& e) {
56076       {
56077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56078       };
56079     } catch (...) {
56080       {
56081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56082       };
56083     }
56084   }
56085   jresult = (int)result;
56086   return jresult;
56087 }
56088
56089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56090   int jresult ;
56091   int result;
56092   {
56093     try
56094     {
56095       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
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 (...) {
56105       {
56106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56107       };
56108     }
56109   }
56110   jresult = (int)result;
56111   return jresult;
56112 }
56113
56114
56115
56116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56117   int jresult ;
56118   int result;
56119
56120   {
56121     try {
56122       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56123     } catch (std::out_of_range& e) {
56124       {
56125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56126       };
56127     } catch (std::exception& e) {
56128       {
56129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56130       };
56131     } catch (Dali::DaliException e) {
56132       {
56133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56134       };
56135     } catch (...) {
56136       {
56137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56138       };
56139     }
56140   }
56141
56142   jresult = (int)result;
56143   return jresult;
56144 }
56145
56146
56147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56148   int jresult ;
56149   int result;
56150
56151   {
56152     try {
56153       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56154     } catch (std::out_of_range& e) {
56155       {
56156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56157       };
56158     } catch (std::exception& e) {
56159       {
56160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56161       };
56162     } catch (Dali::DaliException e) {
56163       {
56164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56165       };
56166     } catch (...) {
56167       {
56168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56169       };
56170     }
56171   }
56172
56173   jresult = (int)result;
56174   return jresult;
56175 }
56176
56177
56178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56179   int jresult ;
56180   int result;
56181
56182   {
56183     try {
56184       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56185     } catch (std::out_of_range& e) {
56186       {
56187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56188       };
56189     } catch (std::exception& e) {
56190       {
56191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56192       };
56193     } catch (Dali::DaliException e) {
56194       {
56195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56196       };
56197     } catch (...) {
56198       {
56199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56200       };
56201     }
56202   }
56203
56204   jresult = (int)result;
56205   return jresult;
56206 }
56207
56208
56209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56210   int jresult ;
56211   int result;
56212
56213   {
56214     try {
56215       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56216     } catch (std::out_of_range& e) {
56217       {
56218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56219       };
56220     } catch (std::exception& e) {
56221       {
56222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56223       };
56224     } catch (Dali::DaliException e) {
56225       {
56226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56227       };
56228     } catch (...) {
56229       {
56230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56231       };
56232     }
56233   }
56234
56235   jresult = (int)result;
56236   return jresult;
56237 }
56238
56239
56240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56241   int jresult ;
56242   int result;
56243
56244   {
56245     try {
56246       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56247     } catch (std::out_of_range& e) {
56248       {
56249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56250       };
56251     } catch (std::exception& e) {
56252       {
56253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56254       };
56255     } catch (Dali::DaliException e) {
56256       {
56257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56258       };
56259     } catch (...) {
56260       {
56261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56262       };
56263     }
56264   }
56265
56266   jresult = (int)result;
56267   return jresult;
56268 }
56269
56270
56271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56272   int jresult ;
56273   int result;
56274
56275   {
56276     try {
56277       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56278     } catch (std::out_of_range& e) {
56279       {
56280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56281       };
56282     } catch (std::exception& e) {
56283       {
56284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56285       };
56286     } catch (Dali::DaliException e) {
56287       {
56288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56289       };
56290     } catch (...) {
56291       {
56292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56293       };
56294     }
56295   }
56296
56297   jresult = (int)result;
56298   return jresult;
56299 }
56300
56301
56302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56303   int jresult ;
56304   int result;
56305
56306   {
56307     try {
56308       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56309     } catch (std::out_of_range& e) {
56310       {
56311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56312       };
56313     } catch (std::exception& e) {
56314       {
56315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56316       };
56317     } catch (Dali::DaliException e) {
56318       {
56319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56320       };
56321     } catch (...) {
56322       {
56323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56324       };
56325     }
56326   }
56327
56328   jresult = (int)result;
56329   return jresult;
56330 }
56331
56332 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56333   int jresult ;
56334   int result;
56335
56336   {
56337     try {
56338       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56339     } catch (std::out_of_range& e) {
56340       {
56341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56342       };
56343     } catch (std::exception& e) {
56344       {
56345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56346       };
56347     } catch (...) {
56348       {
56349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56350       };
56351     }
56352   }
56353   jresult = (int)result;
56354   return jresult;
56355 }
56356
56357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56358   int jresult ;
56359   int result;
56360
56361   {
56362     try {
56363       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56364     } catch (std::out_of_range& e) {
56365       {
56366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56367       };
56368     } catch (std::exception& e) {
56369       {
56370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56371       };
56372     } catch (Dali::DaliException e) {
56373       {
56374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56375       };
56376     } catch (...) {
56377       {
56378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56379       };
56380     }
56381   }
56382
56383   jresult = (int)result;
56384   return jresult;
56385 }
56386
56387
56388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56389   int jresult ;
56390   int result;
56391
56392   {
56393     try {
56394       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56395     } catch (std::out_of_range& e) {
56396       {
56397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56398       };
56399     } catch (std::exception& e) {
56400       {
56401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56402       };
56403     } catch (Dali::DaliException e) {
56404       {
56405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56406       };
56407     } catch (...) {
56408       {
56409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56410       };
56411     }
56412   }
56413
56414   jresult = (int)result;
56415   return jresult;
56416 }
56417
56418
56419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56420   int jresult ;
56421   int result;
56422
56423   {
56424     try {
56425       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56426     } catch (std::out_of_range& e) {
56427       {
56428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56429       };
56430     } catch (std::exception& e) {
56431       {
56432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56433       };
56434     } catch (Dali::DaliException e) {
56435       {
56436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56437       };
56438     } catch (...) {
56439       {
56440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56441       };
56442     }
56443   }
56444
56445   jresult = (int)result;
56446   return jresult;
56447 }
56448
56449
56450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56451   int jresult ;
56452   int result;
56453
56454   {
56455     try {
56456       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56457     } catch (std::out_of_range& e) {
56458       {
56459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56460       };
56461     } catch (std::exception& e) {
56462       {
56463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56464       };
56465     } catch (Dali::DaliException e) {
56466       {
56467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56468       };
56469     } catch (...) {
56470       {
56471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56472       };
56473     }
56474   }
56475
56476   jresult = (int)result;
56477   return jresult;
56478 }
56479
56480
56481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56482   int jresult ;
56483   int result;
56484
56485   {
56486     try {
56487       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56488     } catch (std::out_of_range& e) {
56489       {
56490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56491       };
56492     } catch (std::exception& e) {
56493       {
56494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56495       };
56496     } catch (Dali::DaliException e) {
56497       {
56498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56499       };
56500     } catch (...) {
56501       {
56502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56503       };
56504     }
56505   }
56506
56507   jresult = (int)result;
56508   return jresult;
56509 }
56510
56511
56512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56513   int jresult ;
56514   int result;
56515
56516   {
56517     try {
56518       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56519     } catch (std::out_of_range& e) {
56520       {
56521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56522       };
56523     } catch (std::exception& e) {
56524       {
56525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56526       };
56527     } catch (Dali::DaliException e) {
56528       {
56529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56530       };
56531     } catch (...) {
56532       {
56533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56534       };
56535     }
56536   }
56537
56538   jresult = (int)result;
56539   return jresult;
56540 }
56541
56542
56543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56544   int jresult ;
56545   int result;
56546
56547   {
56548     try {
56549       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56550     } catch (std::out_of_range& e) {
56551       {
56552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56553       };
56554     } catch (std::exception& e) {
56555       {
56556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56557       };
56558     } catch (Dali::DaliException e) {
56559       {
56560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56561       };
56562     } catch (...) {
56563       {
56564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56565       };
56566     }
56567   }
56568
56569   jresult = (int)result;
56570   return jresult;
56571 }
56572
56573
56574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56575   int jresult ;
56576   int result;
56577
56578   {
56579     try {
56580       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56581     } catch (std::out_of_range& e) {
56582       {
56583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56584       };
56585     } catch (std::exception& e) {
56586       {
56587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56588       };
56589     } catch (Dali::DaliException e) {
56590       {
56591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56592       };
56593     } catch (...) {
56594       {
56595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56596       };
56597     }
56598   }
56599
56600   jresult = (int)result;
56601   return jresult;
56602 }
56603
56604
56605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56606   int jresult ;
56607   int result;
56608
56609   {
56610     try {
56611       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56612     } catch (std::out_of_range& e) {
56613       {
56614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56615       };
56616     } catch (std::exception& e) {
56617       {
56618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56619       };
56620     } catch (Dali::DaliException e) {
56621       {
56622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56623       };
56624     } catch (...) {
56625       {
56626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56627       };
56628     }
56629   }
56630
56631   jresult = (int)result;
56632   return jresult;
56633 }
56634
56635
56636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56637   int jresult ;
56638   int result;
56639
56640   {
56641     try {
56642       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56643     } catch (std::out_of_range& e) {
56644       {
56645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56646       };
56647     } catch (std::exception& e) {
56648       {
56649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56650       };
56651     } catch (Dali::DaliException e) {
56652       {
56653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56654       };
56655     } catch (...) {
56656       {
56657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56658       };
56659     }
56660   }
56661
56662   jresult = (int)result;
56663   return jresult;
56664 }
56665
56666
56667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56668   int jresult ;
56669   int result;
56670
56671   {
56672     try {
56673       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56674     } catch (std::out_of_range& e) {
56675       {
56676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56677       };
56678     } catch (std::exception& e) {
56679       {
56680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56681       };
56682     } catch (Dali::DaliException e) {
56683       {
56684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56685       };
56686     } catch (...) {
56687       {
56688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56689       };
56690     }
56691   }
56692
56693   jresult = (int)result;
56694   return jresult;
56695 }
56696
56697
56698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56699   int jresult ;
56700   int result;
56701
56702   {
56703     try {
56704       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56705     } catch (std::out_of_range& e) {
56706       {
56707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56708       };
56709     } catch (std::exception& e) {
56710       {
56711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56712       };
56713     } catch (Dali::DaliException e) {
56714       {
56715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56716       };
56717     } catch (...) {
56718       {
56719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56720       };
56721     }
56722   }
56723
56724   jresult = (int)result;
56725   return jresult;
56726 }
56727
56728
56729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56730   int jresult ;
56731   int result;
56732
56733   {
56734     try {
56735       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56736     } catch (std::out_of_range& e) {
56737       {
56738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56739       };
56740     } catch (std::exception& e) {
56741       {
56742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56743       };
56744     } catch (Dali::DaliException e) {
56745       {
56746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56747       };
56748     } catch (...) {
56749       {
56750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56751       };
56752     }
56753   }
56754
56755   jresult = (int)result;
56756   return jresult;
56757 }
56758
56759
56760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56761   int jresult ;
56762   int result;
56763
56764   {
56765     try {
56766       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56767     } catch (std::out_of_range& e) {
56768       {
56769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56770       };
56771     } catch (std::exception& e) {
56772       {
56773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56774       };
56775     } catch (Dali::DaliException e) {
56776       {
56777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56778       };
56779     } catch (...) {
56780       {
56781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56782       };
56783     }
56784   }
56785
56786   jresult = (int)result;
56787   return jresult;
56788 }
56789
56790
56791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56792   int jresult ;
56793   int result;
56794
56795   {
56796     try {
56797       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56798     } catch (std::out_of_range& e) {
56799       {
56800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56801       };
56802     } catch (std::exception& e) {
56803       {
56804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56805       };
56806     } catch (Dali::DaliException e) {
56807       {
56808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56809       };
56810     } catch (...) {
56811       {
56812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56813       };
56814     }
56815   }
56816
56817   jresult = (int)result;
56818   return jresult;
56819 }
56820
56821
56822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56823   int jresult ;
56824   int result;
56825
56826   {
56827     try {
56828       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56829     } catch (std::out_of_range& e) {
56830       {
56831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56832       };
56833     } catch (std::exception& e) {
56834       {
56835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56836       };
56837     } catch (Dali::DaliException e) {
56838       {
56839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56840       };
56841     } catch (...) {
56842       {
56843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56844       };
56845     }
56846   }
56847
56848   jresult = (int)result;
56849   return jresult;
56850 }
56851
56852
56853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56854   int jresult ;
56855   int result;
56856
56857   {
56858     try {
56859       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56860     } catch (std::out_of_range& e) {
56861       {
56862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56863       };
56864     } catch (std::exception& e) {
56865       {
56866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56867       };
56868     } catch (Dali::DaliException e) {
56869       {
56870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56871       };
56872     } catch (...) {
56873       {
56874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56875       };
56876     }
56877   }
56878
56879   jresult = (int)result;
56880   return jresult;
56881 }
56882
56883
56884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56885   int jresult ;
56886   int result;
56887
56888   {
56889     try {
56890       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56891     } catch (std::out_of_range& e) {
56892       {
56893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56894       };
56895     } catch (std::exception& e) {
56896       {
56897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56898       };
56899     } catch (Dali::DaliException e) {
56900       {
56901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56902       };
56903     } catch (...) {
56904       {
56905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56906       };
56907     }
56908   }
56909
56910   jresult = (int)result;
56911   return jresult;
56912 }
56913
56914
56915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
56916   int jresult ;
56917   int result;
56918
56919   {
56920     try {
56921       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
56922     } catch (std::out_of_range& e) {
56923       {
56924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56925       };
56926     } catch (std::exception& e) {
56927       {
56928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56929       };
56930     } catch (Dali::DaliException e) {
56931       {
56932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56933       };
56934     } catch (...) {
56935       {
56936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56937       };
56938     }
56939   }
56940
56941   jresult = (int)result;
56942   return jresult;
56943 }
56944
56945
56946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
56947   int jresult ;
56948   int result;
56949
56950   {
56951     try {
56952       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
56953     } catch (std::out_of_range& e) {
56954       {
56955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56956       };
56957     } catch (std::exception& e) {
56958       {
56959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56960       };
56961     } catch (Dali::DaliException e) {
56962       {
56963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56964       };
56965     } catch (...) {
56966       {
56967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56968       };
56969     }
56970   }
56971
56972   jresult = (int)result;
56973   return jresult;
56974 }
56975
56976
56977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
56978   int jresult ;
56979   int result;
56980
56981   {
56982     try {
56983       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
56984     } catch (std::out_of_range& e) {
56985       {
56986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56987       };
56988     } catch (std::exception& e) {
56989       {
56990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56991       };
56992     } catch (Dali::DaliException e) {
56993       {
56994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56995       };
56996     } catch (...) {
56997       {
56998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56999       };
57000     }
57001   }
57002
57003   jresult = (int)result;
57004   return jresult;
57005 }
57006
57007
57008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57009   int jresult ;
57010   int result;
57011
57012   {
57013     try {
57014       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57015     } catch (std::out_of_range& e) {
57016       {
57017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57018       };
57019     } catch (std::exception& e) {
57020       {
57021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57022       };
57023     } catch (Dali::DaliException e) {
57024       {
57025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57026       };
57027     } catch (...) {
57028       {
57029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57030       };
57031     }
57032   }
57033
57034   jresult = (int)result;
57035   return jresult;
57036 }
57037
57038
57039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57040   int jresult ;
57041   int result;
57042
57043   {
57044     try {
57045       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57046     } catch (std::out_of_range& e) {
57047       {
57048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57049       };
57050     } catch (std::exception& e) {
57051       {
57052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57053       };
57054     } catch (Dali::DaliException e) {
57055       {
57056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57057       };
57058     } catch (...) {
57059       {
57060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57061       };
57062     }
57063   }
57064
57065   jresult = (int)result;
57066   return jresult;
57067 }
57068
57069
57070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57071   int jresult ;
57072   int result;
57073
57074   {
57075     try {
57076       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57077     } catch (std::out_of_range& e) {
57078       {
57079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57080       };
57081     } catch (std::exception& e) {
57082       {
57083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57084       };
57085     } catch (Dali::DaliException e) {
57086       {
57087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57088       };
57089     } catch (...) {
57090       {
57091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57092       };
57093     }
57094   }
57095
57096   jresult = (int)result;
57097   return jresult;
57098 }
57099
57100
57101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57102   int jresult ;
57103   int result;
57104
57105   {
57106     try {
57107       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57108     } catch (std::out_of_range& e) {
57109       {
57110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57111       };
57112     } catch (std::exception& e) {
57113       {
57114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57115       };
57116     } catch (Dali::DaliException e) {
57117       {
57118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57119       };
57120     } catch (...) {
57121       {
57122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57123       };
57124     }
57125   }
57126
57127   jresult = (int)result;
57128   return jresult;
57129 }
57130
57131
57132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57133   int jresult ;
57134   int result;
57135
57136   {
57137     try {
57138       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57139     } catch (std::out_of_range& e) {
57140       {
57141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57142       };
57143     } catch (std::exception& e) {
57144       {
57145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57146       };
57147     } catch (Dali::DaliException e) {
57148       {
57149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57150       };
57151     } catch (...) {
57152       {
57153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57154       };
57155     }
57156   }
57157
57158   jresult = (int)result;
57159   return jresult;
57160 }
57161
57162
57163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57164   int jresult ;
57165   int result;
57166
57167   {
57168     try {
57169       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57170     } catch (std::out_of_range& e) {
57171       {
57172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57173       };
57174     } catch (std::exception& e) {
57175       {
57176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57177       };
57178     } catch (Dali::DaliException e) {
57179       {
57180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57181       };
57182     } catch (...) {
57183       {
57184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57185       };
57186     }
57187   }
57188
57189   jresult = (int)result;
57190   return jresult;
57191 }
57192
57193
57194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57195   int jresult ;
57196   int result;
57197
57198   {
57199     try {
57200       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57201     } catch (std::out_of_range& e) {
57202       {
57203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57204       };
57205     } catch (std::exception& e) {
57206       {
57207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57208       };
57209     } catch (Dali::DaliException e) {
57210       {
57211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57212       };
57213     } catch (...) {
57214       {
57215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57216       };
57217     }
57218   }
57219
57220   jresult = (int)result;
57221   return jresult;
57222 }
57223
57224
57225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57226   void * jresult ;
57227   Dali::Toolkit::Builder *result = 0 ;
57228
57229   {
57230     try {
57231       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57232     } catch (std::out_of_range& e) {
57233       {
57234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57235       };
57236     } catch (std::exception& e) {
57237       {
57238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57239       };
57240     } catch (Dali::DaliException e) {
57241       {
57242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57243       };
57244     } catch (...) {
57245       {
57246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57247       };
57248     }
57249   }
57250
57251   jresult = (void *)result;
57252   return jresult;
57253 }
57254
57255
57256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57257   void * jresult ;
57258   Dali::Toolkit::Builder result;
57259
57260   {
57261     try {
57262       result = Dali::Toolkit::Builder::New();
57263     } catch (std::out_of_range& e) {
57264       {
57265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57266       };
57267     } catch (std::exception& e) {
57268       {
57269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57270       };
57271     } catch (Dali::DaliException e) {
57272       {
57273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57274       };
57275     } catch (...) {
57276       {
57277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57278       };
57279     }
57280   }
57281
57282   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57283   return jresult;
57284 }
57285
57286
57287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57288   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57289
57290   arg1 = (Dali::Toolkit::Builder *)jarg1;
57291   {
57292     try {
57293       delete arg1;
57294     } catch (std::out_of_range& e) {
57295       {
57296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57297       };
57298     } catch (std::exception& e) {
57299       {
57300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57301       };
57302     } catch (Dali::DaliException e) {
57303       {
57304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57305       };
57306     } catch (...) {
57307       {
57308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57309       };
57310     }
57311   }
57312
57313 }
57314
57315
57316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57317   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57318   std::string *arg2 = 0 ;
57319   Dali::Toolkit::Builder::UIFormat arg3 ;
57320
57321   arg1 = (Dali::Toolkit::Builder *)jarg1;
57322   if (!jarg2) {
57323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57324     return ;
57325   }
57326   std::string arg2_str(jarg2);
57327   arg2 = &arg2_str;
57328   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57329   {
57330     try {
57331       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57332     } catch (std::out_of_range& e) {
57333       {
57334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57335       };
57336     } catch (std::exception& e) {
57337       {
57338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57339       };
57340     } catch (Dali::DaliException e) {
57341       {
57342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57343       };
57344     } catch (...) {
57345       {
57346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57347       };
57348     }
57349   }
57350
57351
57352   //argout typemap for const std::string&
57353
57354 }
57355
57356
57357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57358   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57359   std::string *arg2 = 0 ;
57360
57361   arg1 = (Dali::Toolkit::Builder *)jarg1;
57362   if (!jarg2) {
57363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57364     return ;
57365   }
57366   std::string arg2_str(jarg2);
57367   arg2 = &arg2_str;
57368   {
57369     try {
57370       (arg1)->LoadFromString((std::string const &)*arg2);
57371     } catch (std::out_of_range& e) {
57372       {
57373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57374       };
57375     } catch (std::exception& e) {
57376       {
57377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57378       };
57379     } catch (Dali::DaliException e) {
57380       {
57381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57382       };
57383     } catch (...) {
57384       {
57385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57386       };
57387     }
57388   }
57389
57390
57391   //argout typemap for const std::string&
57392
57393 }
57394
57395
57396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57397   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57398   Dali::Property::Map *arg2 = 0 ;
57399
57400   arg1 = (Dali::Toolkit::Builder *)jarg1;
57401   arg2 = (Dali::Property::Map *)jarg2;
57402   if (!arg2) {
57403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57404     return ;
57405   }
57406   {
57407     try {
57408       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57409     } catch (std::out_of_range& e) {
57410       {
57411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57412       };
57413     } catch (std::exception& e) {
57414       {
57415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57416       };
57417     } catch (Dali::DaliException e) {
57418       {
57419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57420       };
57421     } catch (...) {
57422       {
57423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57424       };
57425     }
57426   }
57427
57428 }
57429
57430
57431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57432   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57433   std::string *arg2 = 0 ;
57434   Dali::Property::Value *arg3 = 0 ;
57435
57436   arg1 = (Dali::Toolkit::Builder *)jarg1;
57437   if (!jarg2) {
57438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57439     return ;
57440   }
57441   std::string arg2_str(jarg2);
57442   arg2 = &arg2_str;
57443   arg3 = (Dali::Property::Value *)jarg3;
57444   if (!arg3) {
57445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57446     return ;
57447   }
57448   {
57449     try {
57450       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57451     } catch (std::out_of_range& e) {
57452       {
57453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57454       };
57455     } catch (std::exception& e) {
57456       {
57457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57458       };
57459     } catch (Dali::DaliException e) {
57460       {
57461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57462       };
57463     } catch (...) {
57464       {
57465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57466       };
57467     }
57468   }
57469
57470
57471   //argout typemap for const std::string&
57472
57473 }
57474
57475
57476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57477   void * jresult ;
57478   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57479   Dali::Property::Map *result = 0 ;
57480
57481   arg1 = (Dali::Toolkit::Builder *)jarg1;
57482   {
57483     try {
57484       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57485     } catch (std::out_of_range& e) {
57486       {
57487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57488       };
57489     } catch (std::exception& e) {
57490       {
57491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57492       };
57493     } catch (Dali::DaliException e) {
57494       {
57495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57496       };
57497     } catch (...) {
57498       {
57499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57500       };
57501     }
57502   }
57503
57504   jresult = (void *)result;
57505   return jresult;
57506 }
57507
57508
57509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57510   void * jresult ;
57511   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57512   std::string *arg2 = 0 ;
57513   Dali::Property::Value *result = 0 ;
57514
57515   arg1 = (Dali::Toolkit::Builder *)jarg1;
57516   if (!jarg2) {
57517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57518     return 0;
57519   }
57520   std::string arg2_str(jarg2);
57521   arg2 = &arg2_str;
57522   {
57523     try {
57524       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57525     } catch (std::out_of_range& e) {
57526       {
57527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57528       };
57529     } catch (std::exception& e) {
57530       {
57531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57532       };
57533     } catch (Dali::DaliException e) {
57534       {
57535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57536       };
57537     } catch (...) {
57538       {
57539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57540       };
57541     }
57542   }
57543
57544   jresult = (void *)result;
57545
57546   //argout typemap for const std::string&
57547
57548   return jresult;
57549 }
57550
57551
57552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57553   void * jresult ;
57554   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57555   std::string *arg2 = 0 ;
57556   Dali::Animation result;
57557
57558   arg1 = (Dali::Toolkit::Builder *)jarg1;
57559   if (!jarg2) {
57560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57561     return 0;
57562   }
57563   std::string arg2_str(jarg2);
57564   arg2 = &arg2_str;
57565   {
57566     try {
57567       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57568     } catch (std::out_of_range& e) {
57569       {
57570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57571       };
57572     } catch (std::exception& e) {
57573       {
57574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57575       };
57576     } catch (Dali::DaliException e) {
57577       {
57578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57579       };
57580     } catch (...) {
57581       {
57582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57583       };
57584     }
57585   }
57586
57587   jresult = new Dali::Animation((const Dali::Animation &)result);
57588
57589   //argout typemap for const std::string&
57590
57591   return jresult;
57592 }
57593
57594
57595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57596   void * jresult ;
57597   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57598   std::string *arg2 = 0 ;
57599   Dali::Property::Map *arg3 = 0 ;
57600   Dali::Animation result;
57601
57602   arg1 = (Dali::Toolkit::Builder *)jarg1;
57603   if (!jarg2) {
57604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57605     return 0;
57606   }
57607   std::string arg2_str(jarg2);
57608   arg2 = &arg2_str;
57609   arg3 = (Dali::Property::Map *)jarg3;
57610   if (!arg3) {
57611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57612     return 0;
57613   }
57614   {
57615     try {
57616       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57617     } catch (std::out_of_range& e) {
57618       {
57619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57620       };
57621     } catch (std::exception& e) {
57622       {
57623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57624       };
57625     } catch (Dali::DaliException e) {
57626       {
57627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57628       };
57629     } catch (...) {
57630       {
57631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57632       };
57633     }
57634   }
57635
57636   jresult = new Dali::Animation((const Dali::Animation &)result);
57637
57638   //argout typemap for const std::string&
57639
57640   return jresult;
57641 }
57642
57643
57644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57645   void * jresult ;
57646   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57647   std::string *arg2 = 0 ;
57648   Dali::Actor arg3 ;
57649   Dali::Actor *argp3 ;
57650   Dali::Animation result;
57651
57652   arg1 = (Dali::Toolkit::Builder *)jarg1;
57653   if (!jarg2) {
57654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57655     return 0;
57656   }
57657   std::string arg2_str(jarg2);
57658   arg2 = &arg2_str;
57659   argp3 = (Dali::Actor *)jarg3;
57660   if (!argp3) {
57661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57662     return 0;
57663   }
57664   arg3 = *argp3;
57665   {
57666     try {
57667       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57668     } catch (std::out_of_range& e) {
57669       {
57670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57671       };
57672     } catch (std::exception& e) {
57673       {
57674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57675       };
57676     } catch (Dali::DaliException e) {
57677       {
57678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57679       };
57680     } catch (...) {
57681       {
57682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57683       };
57684     }
57685   }
57686
57687   jresult = new Dali::Animation((const Dali::Animation &)result);
57688
57689   //argout typemap for const std::string&
57690
57691   return jresult;
57692 }
57693
57694
57695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57696   void * jresult ;
57697   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57698   std::string *arg2 = 0 ;
57699   Dali::Property::Map *arg3 = 0 ;
57700   Dali::Actor arg4 ;
57701   Dali::Actor *argp4 ;
57702   Dali::Animation result;
57703
57704   arg1 = (Dali::Toolkit::Builder *)jarg1;
57705   if (!jarg2) {
57706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57707     return 0;
57708   }
57709   std::string arg2_str(jarg2);
57710   arg2 = &arg2_str;
57711   arg3 = (Dali::Property::Map *)jarg3;
57712   if (!arg3) {
57713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57714     return 0;
57715   }
57716   argp4 = (Dali::Actor *)jarg4;
57717   if (!argp4) {
57718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57719     return 0;
57720   }
57721   arg4 = *argp4;
57722   {
57723     try {
57724       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57725     } catch (std::out_of_range& e) {
57726       {
57727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57728       };
57729     } catch (std::exception& e) {
57730       {
57731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57732       };
57733     } catch (Dali::DaliException e) {
57734       {
57735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57736       };
57737     } catch (...) {
57738       {
57739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57740       };
57741     }
57742   }
57743
57744   jresult = new Dali::Animation((const Dali::Animation &)result);
57745
57746   //argout typemap for const std::string&
57747
57748   return jresult;
57749 }
57750
57751
57752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57753   void * jresult ;
57754   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57755   std::string *arg2 = 0 ;
57756   Dali::BaseHandle result;
57757
57758   arg1 = (Dali::Toolkit::Builder *)jarg1;
57759   if (!jarg2) {
57760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57761     return 0;
57762   }
57763   std::string arg2_str(jarg2);
57764   arg2 = &arg2_str;
57765   {
57766     try {
57767       result = (arg1)->Create((std::string const &)*arg2);
57768     } catch (std::out_of_range& e) {
57769       {
57770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57771       };
57772     } catch (std::exception& e) {
57773       {
57774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57775       };
57776     } catch (Dali::DaliException e) {
57777       {
57778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57779       };
57780     } catch (...) {
57781       {
57782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57783       };
57784     }
57785   }
57786
57787   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57788
57789   //argout typemap for const std::string&
57790
57791   return jresult;
57792 }
57793
57794
57795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57796   void * jresult ;
57797   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57798   std::string *arg2 = 0 ;
57799   Dali::Property::Map *arg3 = 0 ;
57800   Dali::BaseHandle result;
57801
57802   arg1 = (Dali::Toolkit::Builder *)jarg1;
57803   if (!jarg2) {
57804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57805     return 0;
57806   }
57807   std::string arg2_str(jarg2);
57808   arg2 = &arg2_str;
57809   arg3 = (Dali::Property::Map *)jarg3;
57810   if (!arg3) {
57811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57812     return 0;
57813   }
57814   {
57815     try {
57816       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57817     } catch (std::out_of_range& e) {
57818       {
57819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57820       };
57821     } catch (std::exception& e) {
57822       {
57823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57824       };
57825     } catch (Dali::DaliException e) {
57826       {
57827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57828       };
57829     } catch (...) {
57830       {
57831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57832       };
57833     }
57834   }
57835
57836   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57837
57838   //argout typemap for const std::string&
57839
57840   return jresult;
57841 }
57842
57843
57844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57845   void * jresult ;
57846   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57847   std::string *arg2 = 0 ;
57848   Dali::BaseHandle result;
57849
57850   arg1 = (Dali::Toolkit::Builder *)jarg1;
57851   if (!jarg2) {
57852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57853     return 0;
57854   }
57855   std::string arg2_str(jarg2);
57856   arg2 = &arg2_str;
57857   {
57858     try {
57859       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57860     } catch (std::out_of_range& e) {
57861       {
57862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57863       };
57864     } catch (std::exception& e) {
57865       {
57866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57867       };
57868     } catch (Dali::DaliException e) {
57869       {
57870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57871       };
57872     } catch (...) {
57873       {
57874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57875       };
57876     }
57877   }
57878
57879   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57880
57881   //argout typemap for const std::string&
57882
57883   return jresult;
57884 }
57885
57886
57887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57888   unsigned int jresult ;
57889   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57890   std::string *arg2 = 0 ;
57891   Dali::Handle *arg3 = 0 ;
57892   bool result;
57893
57894   arg1 = (Dali::Toolkit::Builder *)jarg1;
57895   if (!jarg2) {
57896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57897     return 0;
57898   }
57899   std::string arg2_str(jarg2);
57900   arg2 = &arg2_str;
57901   arg3 = (Dali::Handle *)jarg3;
57902   if (!arg3) {
57903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57904     return 0;
57905   }
57906   {
57907     try {
57908       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
57909     } catch (std::out_of_range& e) {
57910       {
57911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57912       };
57913     } catch (std::exception& e) {
57914       {
57915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57916       };
57917     } catch (Dali::DaliException e) {
57918       {
57919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57920       };
57921     } catch (...) {
57922       {
57923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57924       };
57925     }
57926   }
57927
57928   jresult = result;
57929
57930   //argout typemap for const std::string&
57931
57932   return jresult;
57933 }
57934
57935
57936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
57937   unsigned int jresult ;
57938   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57939   Dali::Handle *arg2 = 0 ;
57940   std::string *arg3 = 0 ;
57941   bool result;
57942
57943   arg1 = (Dali::Toolkit::Builder *)jarg1;
57944   arg2 = (Dali::Handle *)jarg2;
57945   if (!arg2) {
57946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57947     return 0;
57948   }
57949   if (!jarg3) {
57950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57951     return 0;
57952   }
57953   std::string arg3_str(jarg3);
57954   arg3 = &arg3_str;
57955   {
57956     try {
57957       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
57958     } catch (std::out_of_range& e) {
57959       {
57960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57961       };
57962     } catch (std::exception& e) {
57963       {
57964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57965       };
57966     } catch (Dali::DaliException e) {
57967       {
57968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57969       };
57970     } catch (...) {
57971       {
57972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57973       };
57974     }
57975   }
57976
57977   jresult = result;
57978
57979   //argout typemap for const std::string&
57980
57981   return jresult;
57982 }
57983
57984
57985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
57986   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57987   Dali::Actor arg2 ;
57988   Dali::Actor *argp2 ;
57989
57990   arg1 = (Dali::Toolkit::Builder *)jarg1;
57991   argp2 = (Dali::Actor *)jarg2;
57992   if (!argp2) {
57993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57994     return ;
57995   }
57996   arg2 = *argp2;
57997   {
57998     try {
57999       (arg1)->AddActors(arg2);
58000     } catch (std::out_of_range& e) {
58001       {
58002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58003       };
58004     } catch (std::exception& e) {
58005       {
58006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58007       };
58008     } catch (Dali::DaliException e) {
58009       {
58010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58011       };
58012     } catch (...) {
58013       {
58014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58015       };
58016     }
58017   }
58018
58019 }
58020
58021
58022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58023   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58024   std::string *arg2 = 0 ;
58025   Dali::Actor arg3 ;
58026   Dali::Actor *argp3 ;
58027
58028   arg1 = (Dali::Toolkit::Builder *)jarg1;
58029   if (!jarg2) {
58030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58031     return ;
58032   }
58033   std::string arg2_str(jarg2);
58034   arg2 = &arg2_str;
58035   argp3 = (Dali::Actor *)jarg3;
58036   if (!argp3) {
58037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58038     return ;
58039   }
58040   arg3 = *argp3;
58041   {
58042     try {
58043       (arg1)->AddActors((std::string const &)*arg2,arg3);
58044     } catch (std::out_of_range& e) {
58045       {
58046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58047       };
58048     } catch (std::exception& e) {
58049       {
58050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58051       };
58052     } catch (Dali::DaliException e) {
58053       {
58054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58055       };
58056     } catch (...) {
58057       {
58058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58059       };
58060     }
58061   }
58062
58063
58064   //argout typemap for const std::string&
58065
58066 }
58067
58068
58069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58070   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58071   std::string *arg2 = 0 ;
58072
58073   arg1 = (Dali::Toolkit::Builder *)jarg1;
58074   if (!jarg2) {
58075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58076     return ;
58077   }
58078   std::string arg2_str(jarg2);
58079   arg2 = &arg2_str;
58080   {
58081     try {
58082       (arg1)->CreateRenderTask((std::string const &)*arg2);
58083     } catch (std::out_of_range& e) {
58084       {
58085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58086       };
58087     } catch (std::exception& e) {
58088       {
58089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58090       };
58091     } catch (Dali::DaliException e) {
58092       {
58093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58094       };
58095     } catch (...) {
58096       {
58097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58098       };
58099     }
58100   }
58101
58102
58103   //argout typemap for const std::string&
58104
58105 }
58106
58107
58108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58109   void * jresult ;
58110   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58111   std::string *arg2 = 0 ;
58112   Dali::Path result;
58113
58114   arg1 = (Dali::Toolkit::Builder *)jarg1;
58115   if (!jarg2) {
58116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58117     return 0;
58118   }
58119   std::string arg2_str(jarg2);
58120   arg2 = &arg2_str;
58121   {
58122     try {
58123       result = (arg1)->GetPath((std::string const &)*arg2);
58124     } catch (std::out_of_range& e) {
58125       {
58126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58127       };
58128     } catch (std::exception& e) {
58129       {
58130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58131       };
58132     } catch (Dali::DaliException e) {
58133       {
58134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58135       };
58136     } catch (...) {
58137       {
58138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58139       };
58140     }
58141   }
58142
58143   jresult = new Dali::Path((const Dali::Path &)result);
58144
58145   //argout typemap for const std::string&
58146
58147   return jresult;
58148 }
58149
58150
58151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58152   void * jresult ;
58153   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58154   std::string *arg2 = 0 ;
58155   Dali::PathConstrainer result;
58156
58157   arg1 = (Dali::Toolkit::Builder *)jarg1;
58158   if (!jarg2) {
58159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58160     return 0;
58161   }
58162   std::string arg2_str(jarg2);
58163   arg2 = &arg2_str;
58164   {
58165     try {
58166       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58167     } catch (std::out_of_range& e) {
58168       {
58169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58170       };
58171     } catch (std::exception& e) {
58172       {
58173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58174       };
58175     } catch (Dali::DaliException e) {
58176       {
58177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58178       };
58179     } catch (...) {
58180       {
58181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58182       };
58183     }
58184   }
58185
58186   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58187
58188   //argout typemap for const std::string&
58189
58190   return jresult;
58191 }
58192
58193
58194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58195   void * jresult ;
58196   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58197   std::string *arg2 = 0 ;
58198   Dali::LinearConstrainer result;
58199
58200   arg1 = (Dali::Toolkit::Builder *)jarg1;
58201   if (!jarg2) {
58202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58203     return 0;
58204   }
58205   std::string arg2_str(jarg2);
58206   arg2 = &arg2_str;
58207   {
58208     try {
58209       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58210     } catch (std::out_of_range& e) {
58211       {
58212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58213       };
58214     } catch (std::exception& e) {
58215       {
58216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58217       };
58218     } catch (Dali::DaliException e) {
58219       {
58220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58221       };
58222     } catch (...) {
58223       {
58224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58225       };
58226     }
58227   }
58228
58229   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58230
58231   //argout typemap for const std::string&
58232
58233   return jresult;
58234 }
58235
58236
58237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58238   void * jresult ;
58239   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58240   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58241
58242   arg1 = (Dali::Toolkit::Builder *)jarg1;
58243   {
58244     try {
58245       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58246     } catch (std::out_of_range& e) {
58247       {
58248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58249       };
58250     } catch (std::exception& e) {
58251       {
58252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58253       };
58254     } catch (Dali::DaliException e) {
58255       {
58256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58257       };
58258     } catch (...) {
58259       {
58260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58261       };
58262     }
58263   }
58264
58265   jresult = (void *)result;
58266   return jresult;
58267 }
58268
58269
58270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58271   void * jresult ;
58272   Dali::Toolkit::TransitionData *result = 0 ;
58273
58274   {
58275     try {
58276       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58277     } catch (std::out_of_range& e) {
58278       {
58279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58280       };
58281     } catch (std::exception& e) {
58282       {
58283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58284       };
58285     } catch (Dali::DaliException e) {
58286       {
58287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58288       };
58289     } catch (...) {
58290       {
58291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58292       };
58293     }
58294   }
58295
58296   jresult = (void *)result;
58297   return jresult;
58298 }
58299
58300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58301   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58302
58303   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58304   {
58305     try {
58306       delete arg1;
58307     } catch (std::out_of_range& e) {
58308       {
58309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58310       };
58311     } catch (std::exception& e) {
58312       {
58313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58314       };
58315     } catch (Dali::DaliException e) {
58316       {
58317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58318       };
58319     } catch (...) {
58320       {
58321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58322       };
58323     }
58324   }
58325
58326 }
58327
58328
58329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58330   void * jresult ;
58331   Dali::Property::Map *arg1 = 0 ;
58332   Dali::Toolkit::TransitionData result;
58333
58334   arg1 = (Dali::Property::Map *)jarg1;
58335   if (!arg1) {
58336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58337     return 0;
58338   }
58339   {
58340     try {
58341       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58342     } catch (std::out_of_range& e) {
58343       {
58344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58345       };
58346     } catch (std::exception& e) {
58347       {
58348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58349       };
58350     } catch (Dali::DaliException e) {
58351       {
58352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58353       };
58354     } catch (...) {
58355       {
58356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58357       };
58358     }
58359   }
58360
58361   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58362   return jresult;
58363 }
58364
58365
58366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58367   void * jresult ;
58368   Dali::Property::Array *arg1 = 0 ;
58369   Dali::Toolkit::TransitionData result;
58370
58371   arg1 = (Dali::Property::Array *)jarg1;
58372   if (!arg1) {
58373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58374     return 0;
58375   }
58376   {
58377     try {
58378       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58379     } catch (std::out_of_range& e) {
58380       {
58381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58382       };
58383     } catch (std::exception& e) {
58384       {
58385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58386       };
58387     } catch (Dali::DaliException e) {
58388       {
58389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58390       };
58391     } catch (...) {
58392       {
58393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58394       };
58395     }
58396   }
58397
58398   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58399   return jresult;
58400 }
58401
58402
58403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58404   void * jresult ;
58405   Dali::BaseHandle arg1 ;
58406   Dali::BaseHandle *argp1 ;
58407   Dali::Toolkit::TransitionData result;
58408
58409   argp1 = (Dali::BaseHandle *)jarg1;
58410   if (!argp1) {
58411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58412     return 0;
58413   }
58414   arg1 = *argp1;
58415   {
58416     try {
58417       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58418     } catch (std::out_of_range& e) {
58419       {
58420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58421       };
58422     } catch (std::exception& e) {
58423       {
58424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58425       };
58426     } catch (Dali::DaliException e) {
58427       {
58428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58429       };
58430     } catch (...) {
58431       {
58432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58433       };
58434     }
58435   }
58436
58437   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58438   return jresult;
58439 }
58440
58441
58442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58443   void * jresult ;
58444   Dali::Toolkit::TransitionData *arg1 = 0 ;
58445   Dali::Toolkit::TransitionData *result = 0 ;
58446
58447   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58448   if (!arg1) {
58449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58450     return 0;
58451   }
58452   {
58453     try {
58454       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58455     } catch (std::out_of_range& e) {
58456       {
58457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58458       };
58459     } catch (std::exception& e) {
58460       {
58461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58462       };
58463     } catch (Dali::DaliException e) {
58464       {
58465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58466       };
58467     } catch (...) {
58468       {
58469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58470       };
58471     }
58472   }
58473
58474   jresult = (void *)result;
58475   return jresult;
58476 }
58477
58478
58479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58480   void * jresult ;
58481   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58482   Dali::Toolkit::TransitionData *arg2 = 0 ;
58483   Dali::Toolkit::TransitionData *result = 0 ;
58484
58485   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58486   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58487   if (!arg2) {
58488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58489     return 0;
58490   }
58491   {
58492     try {
58493       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58494     } catch (std::out_of_range& e) {
58495       {
58496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58497       };
58498     } catch (std::exception& e) {
58499       {
58500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58501       };
58502     } catch (Dali::DaliException e) {
58503       {
58504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58505       };
58506     } catch (...) {
58507       {
58508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58509       };
58510     }
58511   }
58512
58513   jresult = (void *)result;
58514   return jresult;
58515 }
58516
58517
58518 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58519   unsigned long jresult ;
58520   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58521   size_t result;
58522
58523   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58524   {
58525     try {
58526       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58527     } catch (std::out_of_range& e) {
58528       {
58529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58530       };
58531     } catch (std::exception& e) {
58532       {
58533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58534       };
58535     } catch (Dali::DaliException e) {
58536       {
58537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58538       };
58539     } catch (...) {
58540       {
58541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58542       };
58543     }
58544   }
58545
58546   jresult = (unsigned long)result;
58547   return jresult;
58548 }
58549
58550
58551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58552   void * jresult ;
58553   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58554   size_t arg2 ;
58555   Dali::Property::Map result;
58556
58557   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58558   arg2 = (size_t)jarg2;
58559   {
58560     try {
58561       result = (arg1)->GetAnimatorAt(arg2);
58562     } catch (std::out_of_range& e) {
58563       {
58564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58565       };
58566     } catch (std::exception& e) {
58567       {
58568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58569       };
58570     } catch (Dali::DaliException e) {
58571       {
58572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58573       };
58574     } catch (...) {
58575       {
58576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58577       };
58578     }
58579   }
58580
58581   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58582   return jresult;
58583 }
58584
58585
58586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58587   int jresult ;
58588   int result;
58589
58590   {
58591     try {
58592       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58593     } catch (std::out_of_range& e) {
58594       {
58595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58596       };
58597     } catch (std::exception& e) {
58598       {
58599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58600       };
58601     } catch (Dali::DaliException e) {
58602       {
58603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58604       };
58605     } catch (...) {
58606       {
58607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58608       };
58609     }
58610   }
58611
58612   jresult = (int)result;
58613   return jresult;
58614 }
58615
58616
58617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58618   int jresult ;
58619   int result;
58620
58621   {
58622     try {
58623       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58624     } catch (std::out_of_range& e) {
58625       {
58626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58627       };
58628     } catch (std::exception& e) {
58629       {
58630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58631       };
58632     } catch (Dali::DaliException e) {
58633       {
58634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58635       };
58636     } catch (...) {
58637       {
58638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58639       };
58640     }
58641   }
58642
58643   jresult = (int)result;
58644   return jresult;
58645 }
58646
58647
58648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58649   int jresult ;
58650   int result;
58651
58652   {
58653     try {
58654       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58655     } catch (std::out_of_range& e) {
58656       {
58657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58658       };
58659     } catch (std::exception& e) {
58660       {
58661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58662       };
58663     } catch (Dali::DaliException e) {
58664       {
58665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58666       };
58667     } catch (...) {
58668       {
58669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58670       };
58671     }
58672   }
58673
58674   jresult = (int)result;
58675   return jresult;
58676 }
58677
58678
58679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58680   int jresult ;
58681   int result;
58682
58683   {
58684     try {
58685       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58686     } catch (std::out_of_range& e) {
58687       {
58688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58689       };
58690     } catch (std::exception& e) {
58691       {
58692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58693       };
58694     } catch (Dali::DaliException e) {
58695       {
58696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58697       };
58698     } catch (...) {
58699       {
58700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58701       };
58702     }
58703   }
58704
58705   jresult = (int)result;
58706   return jresult;
58707 }
58708
58709
58710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58711   int jresult ;
58712   int result;
58713
58714   {
58715     try {
58716       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58717     } catch (std::out_of_range& e) {
58718       {
58719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58720       };
58721     } catch (std::exception& e) {
58722       {
58723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58724       };
58725     } catch (Dali::DaliException e) {
58726       {
58727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58728       };
58729     } catch (...) {
58730       {
58731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58732       };
58733     }
58734   }
58735
58736   jresult = (int)result;
58737   return jresult;
58738 }
58739
58740
58741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58742   int jresult ;
58743   int result;
58744
58745   {
58746     try {
58747       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58748     } catch (std::out_of_range& e) {
58749       {
58750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58751       };
58752     } catch (std::exception& e) {
58753       {
58754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58755       };
58756     } catch (Dali::DaliException e) {
58757       {
58758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58759       };
58760     } catch (...) {
58761       {
58762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58763       };
58764     }
58765   }
58766
58767   jresult = (int)result;
58768   return jresult;
58769 }
58770
58771
58772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58773   int jresult ;
58774   int result;
58775
58776   {
58777     try {
58778       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58779     } catch (std::out_of_range& e) {
58780       {
58781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58782       };
58783     } catch (std::exception& e) {
58784       {
58785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58786       };
58787     } catch (Dali::DaliException e) {
58788       {
58789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58790       };
58791     } catch (...) {
58792       {
58793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58794       };
58795     }
58796   }
58797
58798   jresult = (int)result;
58799   return jresult;
58800 }
58801
58802
58803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58804   int jresult ;
58805   int result;
58806
58807   {
58808     try {
58809       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58810     } catch (std::out_of_range& e) {
58811       {
58812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58813       };
58814     } catch (std::exception& e) {
58815       {
58816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58817       };
58818     } catch (Dali::DaliException e) {
58819       {
58820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58821       };
58822     } catch (...) {
58823       {
58824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58825       };
58826     }
58827   }
58828
58829   jresult = (int)result;
58830   return jresult;
58831 }
58832
58833
58834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58835   int jresult ;
58836   int result;
58837
58838   {
58839     try {
58840       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58841     } catch (std::out_of_range& e) {
58842       {
58843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58844       };
58845     } catch (std::exception& e) {
58846       {
58847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58848       };
58849     } catch (Dali::DaliException e) {
58850       {
58851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58852       };
58853     } catch (...) {
58854       {
58855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58856       };
58857     }
58858   }
58859
58860   jresult = (int)result;
58861   return jresult;
58862 }
58863
58864
58865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58866   int jresult ;
58867   int result;
58868
58869   {
58870     try {
58871       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58872     } catch (std::out_of_range& e) {
58873       {
58874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58875       };
58876     } catch (std::exception& e) {
58877       {
58878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58879       };
58880     } catch (Dali::DaliException e) {
58881       {
58882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58883       };
58884     } catch (...) {
58885       {
58886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58887       };
58888     }
58889   }
58890
58891   jresult = (int)result;
58892   return jresult;
58893 }
58894
58895
58896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58897   int jresult ;
58898   int result;
58899
58900   {
58901     try {
58902       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58903     } catch (std::out_of_range& e) {
58904       {
58905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58906       };
58907     } catch (std::exception& e) {
58908       {
58909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58910       };
58911     } catch (Dali::DaliException e) {
58912       {
58913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58914       };
58915     } catch (...) {
58916       {
58917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58918       };
58919     }
58920   }
58921
58922   jresult = (int)result;
58923   return jresult;
58924 }
58925
58926
58927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58928   int jresult ;
58929   int result;
58930
58931   {
58932     try {
58933       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58934     } catch (std::out_of_range& e) {
58935       {
58936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58937       };
58938     } catch (std::exception& e) {
58939       {
58940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58941       };
58942     } catch (Dali::DaliException e) {
58943       {
58944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58945       };
58946     } catch (...) {
58947       {
58948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58949       };
58950     }
58951   }
58952
58953   jresult = (int)result;
58954   return jresult;
58955 }
58956
58957
58958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58959   int jresult ;
58960   int result;
58961
58962   {
58963     try {
58964       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58965     } catch (std::out_of_range& e) {
58966       {
58967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58968       };
58969     } catch (std::exception& e) {
58970       {
58971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58972       };
58973     } catch (Dali::DaliException e) {
58974       {
58975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58976       };
58977     } catch (...) {
58978       {
58979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58980       };
58981     }
58982   }
58983
58984   jresult = (int)result;
58985   return jresult;
58986 }
58987
58988
58989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58990   int jresult ;
58991   int result;
58992
58993   {
58994     try {
58995       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
58996     } catch (std::out_of_range& e) {
58997       {
58998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58999       };
59000     } catch (std::exception& e) {
59001       {
59002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59003       };
59004     } catch (Dali::DaliException e) {
59005       {
59006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59007       };
59008     } catch (...) {
59009       {
59010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59011       };
59012     }
59013   }
59014
59015   jresult = (int)result;
59016   return jresult;
59017 }
59018
59019
59020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59021   void * jresult ;
59022   Dali::Toolkit::Control result;
59023
59024   {
59025     try {
59026       result = Dali::Toolkit::Internal::Control::New();
59027     } catch (std::out_of_range& e) {
59028       {
59029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59030       };
59031     } catch (std::exception& e) {
59032       {
59033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59034       };
59035     } catch (Dali::DaliException e) {
59036       {
59037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59038       };
59039     } catch (...) {
59040       {
59041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59042       };
59043     }
59044   }
59045
59046   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59047   return jresult;
59048 }
59049
59050
59051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59052   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59053   std::string *arg2 = 0 ;
59054
59055   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59056   if (!jarg2) {
59057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59058     return ;
59059   }
59060   std::string arg2_str(jarg2);
59061   arg2 = &arg2_str;
59062   {
59063     try {
59064       (arg1)->SetStyleName((std::string const &)*arg2);
59065     } catch (std::out_of_range& e) {
59066       {
59067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59068       };
59069     } catch (std::exception& e) {
59070       {
59071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59072       };
59073     } catch (Dali::DaliException e) {
59074       {
59075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59076       };
59077     } catch (...) {
59078       {
59079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59080       };
59081     }
59082   }
59083
59084
59085   //argout typemap for const std::string&
59086
59087 }
59088
59089
59090 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59091   char * jresult ;
59092   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59093   std::string *result = 0 ;
59094
59095   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59096   {
59097     try {
59098       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59099     } catch (std::out_of_range& e) {
59100       {
59101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59102       };
59103     } catch (std::exception& e) {
59104       {
59105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59106       };
59107     } catch (Dali::DaliException e) {
59108       {
59109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59110       };
59111     } catch (...) {
59112       {
59113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59114       };
59115     }
59116   }
59117
59118   jresult = SWIG_csharp_string_callback(result->c_str());
59119   return jresult;
59120 }
59121
59122
59123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59125   Dali::Vector4 *arg2 = 0 ;
59126
59127   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59128   arg2 = (Dali::Vector4 *)jarg2;
59129   if (!arg2) {
59130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59131     return ;
59132   }
59133   {
59134     try {
59135       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59136     } catch (std::out_of_range& e) {
59137       {
59138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59139       };
59140     } catch (std::exception& e) {
59141       {
59142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59143       };
59144     } catch (Dali::DaliException e) {
59145       {
59146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59147       };
59148     } catch (...) {
59149       {
59150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59151       };
59152     }
59153   }
59154
59155 }
59156
59157
59158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59159   void * jresult ;
59160   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59161   Dali::Vector4 result;
59162
59163   arg1 = (Dali::Handle *)jarg1;
59164   {
59165     try {
59166       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59167       if (resultMap)
59168       {
59169         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59170         if(type && type->Get<int>() == Visual::COLOR )
59171         {
59172           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59173           if (value)
59174           {
59175             result = value->Get<Vector4>();
59176           }
59177         }
59178       }
59179     } catch (std::out_of_range& e) {
59180       {
59181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59182       };
59183     } catch (std::exception& e) {
59184       {
59185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59186       };
59187     } catch (Dali::DaliException e) {
59188       {
59189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59190       };
59191     } catch (...) {
59192       {
59193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59194       };
59195     }
59196   }
59197
59198   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59199   return jresult;
59200 }
59201
59202
59203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59205   Dali::Property::Map *arg2 = 0 ;
59206
59207   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59208   arg2 = (Dali::Property::Map *)jarg2;
59209   if (!arg2) {
59210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59211     return ;
59212   }
59213   {
59214     try {
59215       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59216     } catch (std::out_of_range& e) {
59217       {
59218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59219       };
59220     } catch (std::exception& e) {
59221       {
59222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59223       };
59224     } catch (Dali::DaliException e) {
59225       {
59226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59227       };
59228     } catch (...) {
59229       {
59230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59231       };
59232     }
59233   }
59234
59235 }
59236
59237
59238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59239   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59240
59241   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59242   {
59243     try {
59244       (arg1)->ClearBackground();
59245     } catch (std::out_of_range& e) {
59246       {
59247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59248       };
59249     } catch (std::exception& e) {
59250       {
59251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59252       };
59253     } catch (Dali::DaliException e) {
59254       {
59255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59256       };
59257     } catch (...) {
59258       {
59259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59260       };
59261     }
59262   }
59263
59264 }
59265
59266
59267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59268   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59269   Dali::Gesture::Type arg2 ;
59270
59271   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59272   arg2 = (Dali::Gesture::Type)jarg2;
59273   {
59274     try {
59275       (arg1)->EnableGestureDetection(arg2);
59276     } catch (std::out_of_range& e) {
59277       {
59278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59279       };
59280     } catch (std::exception& e) {
59281       {
59282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59283       };
59284     } catch (Dali::DaliException e) {
59285       {
59286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59287       };
59288     } catch (...) {
59289       {
59290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59291       };
59292     }
59293   }
59294
59295 }
59296
59297
59298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59300   Dali::Gesture::Type arg2 ;
59301
59302   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59303   arg2 = (Dali::Gesture::Type)jarg2;
59304   {
59305     try {
59306       (arg1)->DisableGestureDetection(arg2);
59307     } catch (std::out_of_range& e) {
59308       {
59309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59310       };
59311     } catch (std::exception& e) {
59312       {
59313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59314       };
59315     } catch (Dali::DaliException e) {
59316       {
59317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59318       };
59319     } catch (...) {
59320       {
59321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59322       };
59323     }
59324   }
59325
59326 }
59327
59328
59329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59330   void * jresult ;
59331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59332   Dali::PinchGestureDetector result;
59333
59334   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59335   {
59336     try {
59337       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59338     } catch (std::out_of_range& e) {
59339       {
59340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59341       };
59342     } catch (std::exception& e) {
59343       {
59344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59345       };
59346     } catch (Dali::DaliException e) {
59347       {
59348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59349       };
59350     } catch (...) {
59351       {
59352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59353       };
59354     }
59355   }
59356
59357   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59358   return jresult;
59359 }
59360
59361
59362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59363   void * jresult ;
59364   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59365   Dali::PanGestureDetector result;
59366
59367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59368   {
59369     try {
59370       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59371     } catch (std::out_of_range& e) {
59372       {
59373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59374       };
59375     } catch (std::exception& e) {
59376       {
59377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59378       };
59379     } catch (Dali::DaliException e) {
59380       {
59381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59382       };
59383     } catch (...) {
59384       {
59385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59386       };
59387     }
59388   }
59389
59390   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59391   return jresult;
59392 }
59393
59394
59395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59396   void * jresult ;
59397   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59398   Dali::TapGestureDetector result;
59399
59400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59401   {
59402     try {
59403       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59404     } catch (std::out_of_range& e) {
59405       {
59406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59407       };
59408     } catch (std::exception& e) {
59409       {
59410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59411       };
59412     } catch (Dali::DaliException e) {
59413       {
59414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59415       };
59416     } catch (...) {
59417       {
59418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59419       };
59420     }
59421   }
59422
59423   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59424   return jresult;
59425 }
59426
59427
59428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59429   void * jresult ;
59430   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59431   Dali::LongPressGestureDetector result;
59432
59433   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59434   {
59435     try {
59436       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59437     } catch (std::out_of_range& e) {
59438       {
59439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59440       };
59441     } catch (std::exception& e) {
59442       {
59443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59444       };
59445     } catch (Dali::DaliException e) {
59446       {
59447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59448       };
59449     } catch (...) {
59450       {
59451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59452       };
59453     }
59454   }
59455
59456   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59457   return jresult;
59458 }
59459
59460
59461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59462   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59463   bool arg2 ;
59464
59465   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59466   arg2 = jarg2 ? true : false;
59467   {
59468     try {
59469       (arg1)->SetKeyboardNavigationSupport(arg2);
59470     } catch (std::out_of_range& e) {
59471       {
59472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59473       };
59474     } catch (std::exception& e) {
59475       {
59476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59477       };
59478     } catch (Dali::DaliException e) {
59479       {
59480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59481       };
59482     } catch (...) {
59483       {
59484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59485       };
59486     }
59487   }
59488
59489 }
59490
59491
59492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59493   unsigned int jresult ;
59494   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59495   bool result;
59496
59497   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59498   {
59499     try {
59500       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59501     } catch (std::out_of_range& e) {
59502       {
59503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59504       };
59505     } catch (std::exception& e) {
59506       {
59507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59508       };
59509     } catch (Dali::DaliException e) {
59510       {
59511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59512       };
59513     } catch (...) {
59514       {
59515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59516       };
59517     }
59518   }
59519
59520   jresult = result;
59521   return jresult;
59522 }
59523
59524
59525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59526   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59527
59528   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59529   {
59530     try {
59531       (arg1)->SetKeyInputFocus();
59532     } catch (std::out_of_range& e) {
59533       {
59534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59535       };
59536     } catch (std::exception& e) {
59537       {
59538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59539       };
59540     } catch (Dali::DaliException e) {
59541       {
59542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59543       };
59544     } catch (...) {
59545       {
59546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59547       };
59548     }
59549   }
59550
59551 }
59552
59553
59554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59555   unsigned int jresult ;
59556   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59557   bool result;
59558
59559   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59560   {
59561     try {
59562       result = (bool)(arg1)->HasKeyInputFocus();
59563     } catch (std::out_of_range& e) {
59564       {
59565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59566       };
59567     } catch (std::exception& e) {
59568       {
59569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59570       };
59571     } catch (Dali::DaliException e) {
59572       {
59573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59574       };
59575     } catch (...) {
59576       {
59577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59578       };
59579     }
59580   }
59581
59582   jresult = result;
59583   return jresult;
59584 }
59585
59586
59587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59589
59590   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59591   {
59592     try {
59593       (arg1)->ClearKeyInputFocus();
59594     } catch (std::out_of_range& e) {
59595       {
59596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59597       };
59598     } catch (std::exception& e) {
59599       {
59600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59601       };
59602     } catch (Dali::DaliException e) {
59603       {
59604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59605       };
59606     } catch (...) {
59607       {
59608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59609       };
59610     }
59611   }
59612
59613 }
59614
59615
59616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59617   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59618   bool arg2 ;
59619
59620   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59621   arg2 = jarg2 ? true : false;
59622   {
59623     try {
59624       (arg1)->SetAsKeyboardFocusGroup(arg2);
59625     } catch (std::out_of_range& e) {
59626       {
59627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59628       };
59629     } catch (std::exception& e) {
59630       {
59631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59632       };
59633     } catch (Dali::DaliException e) {
59634       {
59635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59636       };
59637     } catch (...) {
59638       {
59639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59640       };
59641     }
59642   }
59643
59644 }
59645
59646
59647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59648   unsigned int jresult ;
59649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59650   bool result;
59651
59652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59653   {
59654     try {
59655       result = (bool)(arg1)->IsKeyboardFocusGroup();
59656     } catch (std::out_of_range& e) {
59657       {
59658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59659       };
59660     } catch (std::exception& e) {
59661       {
59662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59663       };
59664     } catch (Dali::DaliException e) {
59665       {
59666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59667       };
59668     } catch (...) {
59669       {
59670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59671       };
59672     }
59673   }
59674
59675   jresult = result;
59676   return jresult;
59677 }
59678
59679
59680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59681   void * jresult ;
59682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59683   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59684
59685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59686   {
59687     try {
59688       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59689     } catch (std::out_of_range& e) {
59690       {
59691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59692       };
59693     } catch (std::exception& e) {
59694       {
59695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59696       };
59697     } catch (Dali::DaliException e) {
59698       {
59699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59700       };
59701     } catch (...) {
59702       {
59703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59704       };
59705     }
59706   }
59707
59708   jresult = (void *)result;
59709   return jresult;
59710 }
59711
59712
59713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59714   void * jresult ;
59715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59716   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59717
59718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59719   {
59720     try {
59721       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59722     } catch (std::out_of_range& e) {
59723       {
59724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59725       };
59726     } catch (std::exception& e) {
59727       {
59728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59729       };
59730     } catch (Dali::DaliException e) {
59731       {
59732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59733       };
59734     } catch (...) {
59735       {
59736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59737       };
59738     }
59739   }
59740
59741   jresult = (void *)result;
59742   return jresult;
59743 }
59744
59745
59746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59747   void * jresult ;
59748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59749   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59750
59751   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59752   {
59753     try {
59754       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59755     } catch (std::out_of_range& e) {
59756       {
59757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59758       };
59759     } catch (std::exception& e) {
59760       {
59761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59762       };
59763     } catch (Dali::DaliException e) {
59764       {
59765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59766       };
59767     } catch (...) {
59768       {
59769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59770       };
59771     }
59772   }
59773
59774   jresult = (void *)result;
59775   return jresult;
59776 }
59777
59778
59779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
59780   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59781   int arg2 ;
59782   SwigDirector_ViewImpl *darg = 0;
59783
59784   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59785   arg2 = (int)jarg2;
59786   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59787   if(!darg) {
59788     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59789     return;
59790   }
59791   {
59792     try {
59793       if(darg) {
59794         (darg)->OnSceneConnection(arg2);
59795       }
59796     } catch (std::out_of_range& e) {
59797       {
59798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59799       };
59800     } catch (std::exception& e) {
59801       {
59802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59803       };
59804     } catch (Dali::DaliException e) {
59805       {
59806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59807       };
59808     } catch (...) {
59809       {
59810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59811       };
59812     }
59813   }
59814
59815 }
59816
59817
59818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59819   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59820   int arg2 ;
59821   SwigDirector_ViewImpl *darg = 0;
59822
59823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59824   arg2 = (int)jarg2;
59825   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59826   if(!darg) {
59827     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59828     return;
59829   }
59830   {
59831     try {
59832       if(darg) {
59833         (darg)->OnSceneConnectionSwigPublic(arg2);
59834       }
59835     } catch (std::out_of_range& e) {
59836       {
59837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59838       };
59839     } catch (std::exception& e) {
59840       {
59841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59842       };
59843     } catch (Dali::DaliException e) {
59844       {
59845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59846       };
59847     } catch (...) {
59848       {
59849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59850       };
59851     }
59852   }
59853
59854 }
59855
59856
59857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
59858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59859   SwigDirector_ViewImpl *darg = 0;
59860
59861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59862   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59863   if(!darg) {
59864     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59865     return;
59866   }
59867   {
59868     try {
59869       if(darg) {
59870         (darg)->OnSceneDisconnection();
59871       }
59872     } catch (std::out_of_range& e) {
59873       {
59874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59875       };
59876     } catch (std::exception& e) {
59877       {
59878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59879       };
59880     } catch (Dali::DaliException e) {
59881       {
59882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59883       };
59884     } catch (...) {
59885       {
59886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59887       };
59888     }
59889   }
59890
59891 }
59892
59893
59894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
59895   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59896   SwigDirector_ViewImpl *darg = 0;
59897
59898   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59899   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59900   if(!darg) {
59901     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59902     return;
59903   }
59904   {
59905     try {
59906       if(darg) {
59907         (darg)->OnSceneDisconnectionSwigPublic();
59908       }
59909     } catch (std::out_of_range& e) {
59910       {
59911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59912       };
59913     } catch (std::exception& e) {
59914       {
59915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59916       };
59917     } catch (Dali::DaliException e) {
59918       {
59919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59920       };
59921     } catch (...) {
59922       {
59923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59924       };
59925     }
59926   }
59927
59928 }
59929
59930
59931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59932   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59933   Dali::Actor *arg2 = 0 ;
59934   SwigDirector_ViewImpl *darg = 0;
59935
59936   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59937   arg2 = (Dali::Actor *)jarg2;
59938   if (!arg2) {
59939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59940     return ;
59941   }
59942   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59943   if(!darg) {
59944     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59945     return;
59946   }
59947   {
59948     try {
59949       if(darg) {
59950         (darg)->OnChildAdd(*arg2);
59951       }
59952     } catch (std::out_of_range& e) {
59953       {
59954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59955       };
59956     } catch (std::exception& e) {
59957       {
59958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59959       };
59960     } catch (Dali::DaliException e) {
59961       {
59962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59963       };
59964     } catch (...) {
59965       {
59966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59967       };
59968     }
59969   }
59970
59971 }
59972
59973
59974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59976   Dali::Actor *arg2 = 0 ;
59977   SwigDirector_ViewImpl *darg = 0;
59978
59979   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59980   arg2 = (Dali::Actor *)jarg2;
59981   if (!arg2) {
59982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59983     return ;
59984   }
59985   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59986   if(!darg) {
59987     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59988     return;
59989   }
59990   {
59991     try {
59992       if(darg) {
59993           (darg)->OnChildAddSwigPublic(*arg2);
59994       }
59995     } catch (std::out_of_range& e) {
59996       {
59997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59998       };
59999     } catch (std::exception& e) {
60000       {
60001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60002       };
60003     } catch (Dali::DaliException e) {
60004       {
60005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60006       };
60007     } catch (...) {
60008       {
60009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60010       };
60011     }
60012   }
60013
60014 }
60015
60016
60017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60018   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60019   Dali::Actor *arg2 = 0 ;
60020   SwigDirector_ViewImpl *darg = 0;
60021
60022   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60023   arg2 = (Dali::Actor *)jarg2;
60024   if (!arg2) {
60025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60026     return ;
60027   }
60028   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60029   if(!darg) {
60030     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60031     return;
60032   }
60033   {
60034     try {
60035       if(darg) {
60036         (darg)->OnChildRemove(*arg2);
60037       }
60038     } catch (std::out_of_range& e) {
60039       {
60040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60041       };
60042     } catch (std::exception& e) {
60043       {
60044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60045       };
60046     } catch (Dali::DaliException e) {
60047       {
60048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60049       };
60050     } catch (...) {
60051       {
60052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60053       };
60054     }
60055   }
60056
60057 }
60058
60059
60060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60062   Dali::Actor *arg2 = 0 ;
60063   SwigDirector_ViewImpl *darg = 0;
60064
60065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60066   arg2 = (Dali::Actor *)jarg2;
60067   if (!arg2) {
60068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60069     return ;
60070   }
60071   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60072   if(!darg) {
60073     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60074     return;
60075   }
60076   {
60077     try {
60078       if(darg) {
60079         (darg)->OnChildRemoveSwigPublic(*arg2);
60080       }
60081     } catch (std::out_of_range& e) {
60082       {
60083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60084       };
60085     } catch (std::exception& e) {
60086       {
60087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60088       };
60089     } catch (Dali::DaliException e) {
60090       {
60091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60092       };
60093     } catch (...) {
60094       {
60095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60096       };
60097     }
60098   }
60099
60100 }
60101
60102
60103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60104   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60105   Dali::Property::Index arg2 ;
60106   Dali::Property::Value arg3 ;
60107   Dali::Property::Value *argp3 ;
60108   SwigDirector_ViewImpl *darg = 0;
60109
60110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60111   arg2 = (Dali::Property::Index)jarg2;
60112   argp3 = (Dali::Property::Value *)jarg3;
60113   if (!argp3) {
60114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60115     return ;
60116   }
60117   arg3 = *argp3;
60118   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60119   if (!darg) {
60120     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60121     return;
60122   }
60123   {
60124     try {
60125       (darg)->OnPropertySet(arg2,arg3);
60126     } catch (std::out_of_range& e) {
60127       {
60128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60129       };
60130     } catch (std::exception& e) {
60131       {
60132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60133       };
60134     } catch (Dali::DaliException e) {
60135       {
60136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60137       };
60138     } catch (...) {
60139       {
60140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60141       };
60142     }
60143   }
60144
60145 }
60146
60147
60148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60150   Dali::Property::Index arg2 ;
60151   Dali::Property::Value arg3 ;
60152   Dali::Property::Value *argp3 ;
60153   SwigDirector_ViewImpl *darg = 0;
60154
60155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60156   arg2 = (Dali::Property::Index)jarg2;
60157   argp3 = (Dali::Property::Value *)jarg3;
60158   if (!argp3) {
60159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60160     return ;
60161   }
60162   arg3 = *argp3;
60163   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60164   if (!darg) {
60165     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60166     return;
60167   }
60168   {
60169     try {
60170       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60171     } catch (std::out_of_range& e) {
60172       {
60173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60174       };
60175     } catch (std::exception& e) {
60176       {
60177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60178       };
60179     } catch (Dali::DaliException e) {
60180       {
60181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60182       };
60183     } catch (...) {
60184       {
60185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60186       };
60187     }
60188   }
60189
60190 }
60191
60192
60193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60195   Dali::Vector3 *arg2 = 0 ;
60196   SwigDirector_ViewImpl *darg = 0;
60197
60198   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60199   arg2 = (Dali::Vector3 *)jarg2;
60200   if (!arg2) {
60201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60202     return ;
60203   }
60204   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60205   if (!darg) {
60206     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60207     return;
60208   }
60209   {
60210     try {
60211       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60212     } catch (std::out_of_range& e) {
60213       {
60214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60215       };
60216     } catch (std::exception& e) {
60217       {
60218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60219       };
60220     } catch (Dali::DaliException e) {
60221       {
60222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60223       };
60224     } catch (...) {
60225       {
60226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60227       };
60228     }
60229   }
60230
60231 }
60232
60233
60234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60235   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60236   Dali::Vector3 *arg2 = 0 ;
60237   SwigDirector_ViewImpl *darg = 0;
60238
60239   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60240   arg2 = (Dali::Vector3 *)jarg2;
60241   if (!arg2) {
60242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60243     return ;
60244   }
60245   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60246   if (!darg) {
60247     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60248     return;
60249   }
60250   {
60251     try {
60252       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60253     } catch (std::out_of_range& e) {
60254       {
60255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60256       };
60257     } catch (std::exception& e) {
60258       {
60259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60260       };
60261     } catch (Dali::DaliException e) {
60262       {
60263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60264       };
60265     } catch (...) {
60266       {
60267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60268       };
60269     }
60270   }
60271
60272 }
60273
60274
60275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60277   Dali::Animation *arg2 = 0 ;
60278   Dali::Vector3 *arg3 = 0 ;
60279   SwigDirector_ViewImpl *darg = 0;
60280
60281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60282   arg2 = (Dali::Animation *)jarg2;
60283   if (!arg2) {
60284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60285     return ;
60286   }
60287   arg3 = (Dali::Vector3 *)jarg3;
60288   if (!arg3) {
60289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60290     return ;
60291   }
60292   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60293   if (!darg) {
60294     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60295     return;
60296   }
60297   {
60298     try {
60299       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60300     } catch (std::out_of_range& e) {
60301       {
60302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60303       };
60304     } catch (std::exception& e) {
60305       {
60306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60307       };
60308     } catch (Dali::DaliException e) {
60309       {
60310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60311       };
60312     } catch (...) {
60313       {
60314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60315       };
60316     }
60317   }
60318
60319 }
60320
60321
60322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60324   Dali::Animation *arg2 = 0 ;
60325   Dali::Vector3 *arg3 = 0 ;
60326   SwigDirector_ViewImpl *darg = 0;
60327
60328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60329   arg2 = (Dali::Animation *)jarg2;
60330   if (!arg2) {
60331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60332     return ;
60333   }
60334   arg3 = (Dali::Vector3 *)jarg3;
60335   if (!arg3) {
60336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60337     return ;
60338   }
60339   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60340   if (!darg) {
60341     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60342     return;
60343   }
60344   {
60345     try {
60346       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60347     } catch (std::out_of_range& e) {
60348       {
60349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60350       };
60351     } catch (std::exception& e) {
60352       {
60353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60354       };
60355     } catch (Dali::DaliException e) {
60356       {
60357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60358       };
60359     } catch (...) {
60360       {
60361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60362       };
60363     }
60364   }
60365
60366 }
60367
60368
60369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60370   unsigned int jresult ;
60371   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60372   Dali::TouchEvent *arg2 = 0 ;
60373   SwigDirector_ViewImpl *darg = 0;
60374   bool result;
60375
60376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60377   arg2 = (Dali::TouchEvent *)jarg2;
60378   if (!arg2) {
60379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60380     return 0;
60381   }
60382   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60383   if (!darg) {
60384     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60385     return 0;
60386   }
60387   {
60388     try {
60389       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60390     } catch (std::out_of_range& e) {
60391       {
60392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60393       };
60394     } catch (std::exception& e) {
60395       {
60396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60397       };
60398     } catch (Dali::DaliException e) {
60399       {
60400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60401       };
60402     } catch (...) {
60403       {
60404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60405       };
60406     }
60407   }
60408
60409   jresult = result;
60410   return jresult;
60411 }
60412
60413
60414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60415   unsigned int jresult ;
60416   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60417   Dali::TouchEvent *arg2 = 0 ;
60418   SwigDirector_ViewImpl *darg = 0;
60419   bool result;
60420
60421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60422   arg2 = (Dali::TouchEvent *)jarg2;
60423   if (!arg2) {
60424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60425     return 0;
60426   }
60427   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60428   if (!darg) {
60429     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60430     return 0;
60431   }
60432   {
60433     try {
60434       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60435     } catch (std::out_of_range& e) {
60436       {
60437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60438       };
60439     } catch (std::exception& e) {
60440       {
60441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60442       };
60443     } catch (Dali::DaliException e) {
60444       {
60445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60446       };
60447     } catch (...) {
60448       {
60449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60450       };
60451     }
60452   }
60453
60454   jresult = result;
60455   return jresult;
60456 }
60457
60458
60459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60460   unsigned int jresult ;
60461   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60462   Dali::HoverEvent *arg2 = 0 ;
60463   SwigDirector_ViewImpl *darg = 0;
60464   bool result;
60465
60466   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60467   arg2 = (Dali::HoverEvent *)jarg2;
60468   if (!arg2) {
60469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60470     return 0;
60471   }
60472   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60473   if (!darg) {
60474     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60475     return 0;
60476   }
60477   {
60478     try {
60479       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60480     } catch (std::out_of_range& e) {
60481       {
60482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60483       };
60484     } catch (std::exception& e) {
60485       {
60486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60487       };
60488     } catch (Dali::DaliException e) {
60489       {
60490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60491       };
60492     } catch (...) {
60493       {
60494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60495       };
60496     }
60497   }
60498
60499   jresult = result;
60500   return jresult;
60501 }
60502
60503
60504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60505   unsigned int jresult ;
60506   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60507   Dali::HoverEvent *arg2 = 0 ;
60508   SwigDirector_ViewImpl *darg = 0;
60509   bool result;
60510
60511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60512   arg2 = (Dali::HoverEvent *)jarg2;
60513   if (!arg2) {
60514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60515     return 0;
60516   }
60517   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60518   if (!darg) {
60519     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60520     return 0;
60521   }
60522   {
60523     try {
60524       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60525     } catch (std::out_of_range& e) {
60526       {
60527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60528       };
60529     } catch (std::exception& e) {
60530       {
60531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60532       };
60533     } catch (Dali::DaliException e) {
60534       {
60535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60536       };
60537     } catch (...) {
60538       {
60539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60540       };
60541     }
60542   }
60543
60544   jresult = result;
60545   return jresult;
60546 }
60547
60548
60549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60550   unsigned int jresult ;
60551   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60552   Dali::KeyEvent *arg2 = 0 ;
60553   SwigDirector_ViewImpl *darg = 0;
60554   bool result;
60555
60556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60557   arg2 = (Dali::KeyEvent *)jarg2;
60558   if (!arg2) {
60559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60560     return 0;
60561   }
60562   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60563   if (!darg) {
60564     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60565     return 0;
60566   }
60567   {
60568     try {
60569       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60570     } catch (std::out_of_range& e) {
60571       {
60572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60573       };
60574     } catch (std::exception& e) {
60575       {
60576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60577       };
60578     } catch (Dali::DaliException e) {
60579       {
60580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60581       };
60582     } catch (...) {
60583       {
60584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60585       };
60586     }
60587   }
60588
60589   jresult = result;
60590   return jresult;
60591 }
60592
60593
60594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60595   unsigned int jresult ;
60596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60597   Dali::KeyEvent *arg2 = 0 ;
60598   SwigDirector_ViewImpl *darg = 0;
60599   bool result;
60600
60601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60602   arg2 = (Dali::KeyEvent *)jarg2;
60603   if (!arg2) {
60604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60605     return 0;
60606   }
60607   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60608   if (!darg) {
60609     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60610     return 0;
60611   }
60612   {
60613     try {
60614       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60615     } catch (std::out_of_range& e) {
60616       {
60617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60618       };
60619     } catch (std::exception& e) {
60620       {
60621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60622       };
60623     } catch (Dali::DaliException e) {
60624       {
60625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60626       };
60627     } catch (...) {
60628       {
60629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60630       };
60631     }
60632   }
60633
60634   jresult = result;
60635   return jresult;
60636 }
60637
60638
60639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60640   unsigned int jresult ;
60641   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60642   Dali::WheelEvent *arg2 = 0 ;
60643   SwigDirector_ViewImpl *darg = 0;
60644   bool result;
60645
60646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60647   arg2 = (Dali::WheelEvent *)jarg2;
60648   if (!arg2) {
60649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60650     return 0;
60651   }
60652   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60653   if (!darg) {
60654     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60655     return 0;
60656   }
60657   {
60658     try {
60659       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60660     } catch (std::out_of_range& e) {
60661       {
60662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60663       };
60664     } catch (std::exception& e) {
60665       {
60666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60667       };
60668     } catch (Dali::DaliException e) {
60669       {
60670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60671       };
60672     } catch (...) {
60673       {
60674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60675       };
60676     }
60677   }
60678
60679   jresult = result;
60680   return jresult;
60681 }
60682
60683
60684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60685   unsigned int jresult ;
60686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60687   Dali::WheelEvent *arg2 = 0 ;
60688   SwigDirector_ViewImpl *darg = 0;
60689   bool result;
60690
60691   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60692   arg2 = (Dali::WheelEvent *)jarg2;
60693   if (!arg2) {
60694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60695     return 0;
60696   }
60697   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60698   if (!darg) {
60699     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60700     return 0;
60701   }
60702   {
60703     try {
60704       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60705     } catch (std::out_of_range& e) {
60706       {
60707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60708       };
60709     } catch (std::exception& e) {
60710       {
60711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60712       };
60713     } catch (Dali::DaliException e) {
60714       {
60715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60716       };
60717     } catch (...) {
60718       {
60719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60720       };
60721     }
60722   }
60723
60724   jresult = result;
60725   return jresult;
60726 }
60727
60728
60729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60731   Dali::Vector2 *arg2 = 0 ;
60732   Dali::RelayoutContainer *arg3 = 0 ;
60733   SwigDirector_ViewImpl *darg = 0;
60734
60735   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60736   arg2 = (Dali::Vector2 *)jarg2;
60737   if (!arg2) {
60738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60739     return ;
60740   }
60741   arg3 = (Dali::RelayoutContainer *)jarg3;
60742   if (!arg3) {
60743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60744     return ;
60745   }
60746   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60747   if (!darg) {
60748     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60749     return;
60750   }
60751   {
60752     try {
60753       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60754     } catch (std::out_of_range& e) {
60755       {
60756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60757       };
60758     } catch (std::exception& e) {
60759       {
60760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60761       };
60762     } catch (Dali::DaliException e) {
60763       {
60764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60765       };
60766     } catch (...) {
60767       {
60768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60769       };
60770     }
60771   }
60772
60773 }
60774
60775
60776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60777   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60778   Dali::Vector2 *arg2 = 0 ;
60779   Dali::RelayoutContainer *arg3 = 0 ;
60780   SwigDirector_ViewImpl *darg = 0;
60781
60782   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60783   arg2 = (Dali::Vector2 *)jarg2;
60784   if (!arg2) {
60785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60786     return ;
60787   }
60788   arg3 = (Dali::RelayoutContainer *)jarg3;
60789   if (!arg3) {
60790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60791     return ;
60792   }
60793   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60794   if (!darg) {
60795     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60796     return;
60797   }
60798   {
60799     try {
60800       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60801     } catch (std::out_of_range& e) {
60802       {
60803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60804       };
60805     } catch (std::exception& e) {
60806       {
60807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60808       };
60809     } catch (Dali::DaliException e) {
60810       {
60811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60812       };
60813     } catch (...) {
60814       {
60815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60816       };
60817     }
60818   }
60819
60820 }
60821
60822
60823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60824   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60825   Dali::ResizePolicy::Type arg2 ;
60826   Dali::Dimension::Type arg3 ;
60827   SwigDirector_ViewImpl *darg = 0;
60828
60829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60830   arg2 = (Dali::ResizePolicy::Type)jarg2;
60831   arg3 = (Dali::Dimension::Type)jarg3;
60832   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60833   if (!darg) {
60834     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60835     return;
60836   }
60837   {
60838     try {
60839       (darg)->OnSetResizePolicy(arg2,arg3);
60840     } catch (std::out_of_range& e) {
60841       {
60842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60843       };
60844     } catch (std::exception& e) {
60845       {
60846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60847       };
60848     } catch (Dali::DaliException e) {
60849       {
60850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60851       };
60852     } catch (...) {
60853       {
60854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60855       };
60856     }
60857   }
60858
60859 }
60860
60861
60862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60863   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60864   Dali::ResizePolicy::Type arg2 ;
60865   Dali::Dimension::Type arg3 ;
60866   SwigDirector_ViewImpl *darg = 0;
60867
60868   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60869   arg2 = (Dali::ResizePolicy::Type)jarg2;
60870   arg3 = (Dali::Dimension::Type)jarg3;
60871   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60872   if (!darg) {
60873     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60874     return;
60875   }
60876   {
60877     try {
60878       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60879     } catch (std::out_of_range& e) {
60880       {
60881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60882       };
60883     } catch (std::exception& e) {
60884       {
60885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60886       };
60887     } catch (Dali::DaliException e) {
60888       {
60889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60890       };
60891     } catch (...) {
60892       {
60893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60894       };
60895     }
60896   }
60897
60898 }
60899
60900
60901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60902   void * jresult ;
60903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60904   SwigDirector_ViewImpl *darg = 0;
60905   Dali::Vector3 result;
60906
60907   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60908   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60909   if (!darg) {
60910     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60911     return 0;
60912   }
60913   {
60914     try {
60915       result = (darg)->GetNaturalSize();
60916     } catch (std::out_of_range& e) {
60917       {
60918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60919       };
60920     } catch (std::exception& e) {
60921       {
60922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60923       };
60924     } catch (Dali::DaliException e) {
60925       {
60926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60927       };
60928     } catch (...) {
60929       {
60930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60931       };
60932     }
60933   }
60934
60935   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60936   return jresult;
60937 }
60938
60939
60940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60941   void * jresult ;
60942   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60943   SwigDirector_ViewImpl *darg = 0;
60944   Dali::Vector3 result;
60945
60946   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60947   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60948   if (!darg) {
60949     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60950     return 0;
60951   }
60952   {
60953     try {
60954       result = (darg)->GetNaturalSizeSwigPublic();
60955     } catch (std::out_of_range& e) {
60956       {
60957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60958       };
60959     } catch (std::exception& e) {
60960       {
60961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60962       };
60963     } catch (Dali::DaliException e) {
60964       {
60965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60966       };
60967     } catch (...) {
60968       {
60969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60970       };
60971     }
60972   }
60973
60974   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60975   return jresult;
60976 }
60977
60978
60979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60980   float jresult ;
60981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60982   Dali::Actor *arg2 = 0 ;
60983   Dali::Dimension::Type arg3 ;
60984   SwigDirector_ViewImpl *darg = 0;
60985   float result;
60986
60987   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60988   arg2 = (Dali::Actor *)jarg2;
60989   if (!arg2) {
60990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60991     return 0;
60992   }
60993   arg3 = (Dali::Dimension::Type)jarg3;
60994   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60995   if (!darg) {
60996     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60997     return 0;
60998   }
60999   {
61000     try {
61001       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61002     } catch (std::out_of_range& e) {
61003       {
61004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61005       };
61006     } catch (std::exception& e) {
61007       {
61008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61009       };
61010     } catch (Dali::DaliException e) {
61011       {
61012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61013       };
61014     } catch (...) {
61015       {
61016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61017       };
61018     }
61019   }
61020
61021   jresult = result;
61022   return jresult;
61023 }
61024
61025
61026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61027   float jresult ;
61028   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61029   Dali::Actor *arg2 = 0 ;
61030   Dali::Dimension::Type arg3 ;
61031   SwigDirector_ViewImpl *darg = 0;
61032   float result;
61033
61034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61035   arg2 = (Dali::Actor *)jarg2;
61036   if (!arg2) {
61037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61038     return 0;
61039   }
61040   arg3 = (Dali::Dimension::Type)jarg3;
61041   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61042   if (!darg) {
61043     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61044     return 0;
61045   }
61046   {
61047     try {
61048       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61049     } catch (std::out_of_range& e) {
61050       {
61051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61052       };
61053     } catch (std::exception& e) {
61054       {
61055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61056       };
61057     } catch (Dali::DaliException e) {
61058       {
61059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61060       };
61061     } catch (...) {
61062       {
61063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61064       };
61065     }
61066   }
61067
61068   jresult = result;
61069   return jresult;
61070 }
61071
61072
61073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61074   float jresult ;
61075   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61076   float arg2 ;
61077   SwigDirector_ViewImpl *darg = 0;
61078   float result;
61079
61080   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61081   arg2 = (float)jarg2;
61082   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61083   if (!darg) {
61084     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61085     return 0;
61086   }
61087   {
61088     try {
61089       result = (float)(darg)->GetHeightForWidth(arg2);
61090     } catch (std::out_of_range& e) {
61091       {
61092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61093       };
61094     } catch (std::exception& e) {
61095       {
61096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61097       };
61098     } catch (Dali::DaliException e) {
61099       {
61100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61101       };
61102     } catch (...) {
61103       {
61104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61105       };
61106     }
61107   }
61108
61109   jresult = result;
61110   return jresult;
61111 }
61112
61113
61114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61115   float jresult ;
61116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61117   float arg2 ;
61118   SwigDirector_ViewImpl *darg = 0;
61119   float result;
61120
61121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61122   arg2 = (float)jarg2;
61123   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61124   if (!darg) {
61125     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61126     return 0;
61127   }
61128   {
61129     try {
61130       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61131     } catch (std::out_of_range& e) {
61132       {
61133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61134       };
61135     } catch (std::exception& e) {
61136       {
61137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61138       };
61139     } catch (Dali::DaliException e) {
61140       {
61141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61142       };
61143     } catch (...) {
61144       {
61145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61146       };
61147     }
61148   }
61149
61150   jresult = result;
61151   return jresult;
61152 }
61153
61154
61155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61156   float jresult ;
61157   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61158   float arg2 ;
61159   SwigDirector_ViewImpl *darg = 0;
61160   float result;
61161
61162   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61163   arg2 = (float)jarg2;
61164   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61165   if (!darg) {
61166     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61167     return 0;
61168   }
61169   {
61170     try {
61171       result = (float)(darg)->GetWidthForHeight(arg2);
61172     } catch (std::out_of_range& e) {
61173       {
61174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61175       };
61176     } catch (std::exception& e) {
61177       {
61178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61179       };
61180     } catch (Dali::DaliException e) {
61181       {
61182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61183       };
61184     } catch (...) {
61185       {
61186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61187       };
61188     }
61189   }
61190
61191   jresult = result;
61192   return jresult;
61193 }
61194
61195
61196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61197   float jresult ;
61198   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61199   float arg2 ;
61200   SwigDirector_ViewImpl *darg = 0;
61201   float result;
61202
61203   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61204   arg2 = (float)jarg2;
61205   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61206   if (!darg) {
61207     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61208     return 0;
61209   }
61210   {
61211     try {
61212       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61213     } catch (std::out_of_range& e) {
61214       {
61215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61216       };
61217     } catch (std::exception& e) {
61218       {
61219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61220       };
61221     } catch (Dali::DaliException e) {
61222       {
61223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61224       };
61225     } catch (...) {
61226       {
61227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61228       };
61229     }
61230   }
61231
61232   jresult = result;
61233   return jresult;
61234 }
61235
61236
61237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61238   unsigned int jresult ;
61239   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61240   Dali::Dimension::Type arg2 ;
61241   SwigDirector_ViewImpl *darg = 0;
61242   bool result;
61243
61244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61245   arg2 = (Dali::Dimension::Type)jarg2;
61246   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61247   if (!darg) {
61248     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61249     return 0;
61250   }
61251   {
61252     try {
61253       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61254     } catch (std::out_of_range& e) {
61255       {
61256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61257       };
61258     } catch (std::exception& e) {
61259       {
61260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61261       };
61262     } catch (Dali::DaliException e) {
61263       {
61264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61265       };
61266     } catch (...) {
61267       {
61268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61269       };
61270     }
61271   }
61272
61273   jresult = result;
61274   return jresult;
61275 }
61276
61277
61278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61279   unsigned int jresult ;
61280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61281   Dali::Dimension::Type arg2 ;
61282   SwigDirector_ViewImpl *darg = 0;
61283   bool result;
61284
61285   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61286   arg2 = (Dali::Dimension::Type)jarg2;
61287   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61288   if (!darg) {
61289     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61290     return 0;
61291   }
61292   {
61293     try {
61294       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61295     } catch (std::out_of_range& e) {
61296       {
61297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61298       };
61299     } catch (std::exception& e) {
61300       {
61301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61302       };
61303     } catch (Dali::DaliException e) {
61304       {
61305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61306       };
61307     } catch (...) {
61308       {
61309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61310       };
61311     }
61312   }
61313
61314   jresult = result;
61315   return jresult;
61316 }
61317
61318
61319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61320   unsigned int jresult ;
61321   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61322   SwigDirector_ViewImpl *darg = 0;
61323   bool result;
61324
61325   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61326   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61327   if (!darg) {
61328     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61329     return 0;
61330   }
61331   {
61332     try {
61333       result = (bool)(darg)->RelayoutDependentOnChildren();
61334     } catch (std::out_of_range& e) {
61335       {
61336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61337       };
61338     } catch (std::exception& e) {
61339       {
61340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61341       };
61342     } catch (Dali::DaliException e) {
61343       {
61344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61345       };
61346     } catch (...) {
61347       {
61348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61349       };
61350     }
61351   }
61352
61353   jresult = result;
61354   return jresult;
61355 }
61356
61357
61358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61359   unsigned int jresult ;
61360   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61361   SwigDirector_ViewImpl *darg = 0;
61362   bool result;
61363
61364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61365   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61366   if (!darg) {
61367     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61368     return 0;
61369   }
61370   {
61371     try {
61372       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61373     } catch (std::out_of_range& e) {
61374       {
61375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61376       };
61377     } catch (std::exception& e) {
61378       {
61379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61380       };
61381     } catch (Dali::DaliException e) {
61382       {
61383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61384       };
61385     } catch (...) {
61386       {
61387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61388       };
61389     }
61390   }
61391
61392   jresult = result;
61393   return jresult;
61394 }
61395
61396
61397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61399   Dali::Dimension::Type arg2 ;
61400   SwigDirector_ViewImpl *darg = 0;
61401
61402   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61403   arg2 = (Dali::Dimension::Type)jarg2;
61404   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61405   if (!darg) {
61406     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61407     return;
61408   }
61409   {
61410     try {
61411       (darg)->OnCalculateRelayoutSize(arg2);
61412     } catch (std::out_of_range& e) {
61413       {
61414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61415       };
61416     } catch (std::exception& e) {
61417       {
61418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61419       };
61420     } catch (Dali::DaliException e) {
61421       {
61422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61423       };
61424     } catch (...) {
61425       {
61426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61427       };
61428     }
61429   }
61430
61431 }
61432
61433
61434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61435   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61436   Dali::Dimension::Type arg2 ;
61437   SwigDirector_ViewImpl *darg = 0;
61438
61439   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61440   arg2 = (Dali::Dimension::Type)jarg2;
61441   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61442   if (!darg) {
61443     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61444     return;
61445   }
61446   {
61447     try {
61448       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61449     } catch (std::out_of_range& e) {
61450       {
61451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61452       };
61453     } catch (std::exception& e) {
61454       {
61455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61456       };
61457     } catch (Dali::DaliException e) {
61458       {
61459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61460       };
61461     } catch (...) {
61462       {
61463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61464       };
61465     }
61466   }
61467
61468 }
61469
61470
61471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61472   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61473   float arg2 ;
61474   Dali::Dimension::Type arg3 ;
61475   SwigDirector_ViewImpl *darg = 0;
61476
61477   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61478   arg2 = (float)jarg2;
61479   arg3 = (Dali::Dimension::Type)jarg3;
61480   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61481   if (!darg) {
61482     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61483     return;
61484   }
61485   {
61486     try {
61487       (darg)->OnLayoutNegotiated(arg2,arg3);
61488     } catch (std::out_of_range& e) {
61489       {
61490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61491       };
61492     } catch (std::exception& e) {
61493       {
61494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61495       };
61496     } catch (Dali::DaliException e) {
61497       {
61498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61499       };
61500     } catch (...) {
61501       {
61502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61503       };
61504     }
61505   }
61506
61507 }
61508
61509
61510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61511   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61512   float arg2 ;
61513   Dali::Dimension::Type arg3 ;
61514   SwigDirector_ViewImpl *darg = 0;
61515
61516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61517   arg2 = (float)jarg2;
61518   arg3 = (Dali::Dimension::Type)jarg3;
61519   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61520   if (!darg) {
61521     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61522     return;
61523   }
61524   {
61525     try {
61526       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61527     } catch (std::out_of_range& e) {
61528       {
61529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61530       };
61531     } catch (std::exception& e) {
61532       {
61533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61534       };
61535     } catch (Dali::DaliException e) {
61536       {
61537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61538       };
61539     } catch (...) {
61540       {
61541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61542       };
61543     }
61544   }
61545
61546 }
61547
61548
61549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61551
61552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61553   {
61554     try {
61555       (arg1)->OnInitialize();
61556     } catch (std::out_of_range& e) {
61557       {
61558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61559       };
61560     } catch (std::exception& e) {
61561       {
61562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61563       };
61564     } catch (Dali::DaliException e) {
61565       {
61566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61567       };
61568     } catch (...) {
61569       {
61570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61571       };
61572     }
61573   }
61574
61575 }
61576
61577
61578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61579   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61580
61581   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61582   {
61583     try {
61584       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61585     } catch (std::out_of_range& e) {
61586       {
61587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61588       };
61589     } catch (std::exception& e) {
61590       {
61591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61592       };
61593     } catch (Dali::DaliException e) {
61594       {
61595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61596       };
61597     } catch (...) {
61598       {
61599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61600       };
61601     }
61602   }
61603
61604 }
61605
61606
61607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61609   Dali::Toolkit::StyleManager arg2 ;
61610   Dali::StyleChange::Type arg3 ;
61611   Dali::Toolkit::StyleManager *argp2 ;
61612
61613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61614   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61615   if (!argp2) {
61616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61617     return ;
61618   }
61619   arg2 = *argp2;
61620   arg3 = (Dali::StyleChange::Type)jarg3;
61621   {
61622     try {
61623       (arg1)->OnStyleChange(arg2,arg3);
61624     } catch (std::out_of_range& e) {
61625       {
61626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61627       };
61628     } catch (std::exception& e) {
61629       {
61630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61631       };
61632     } catch (Dali::DaliException e) {
61633       {
61634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61635       };
61636     } catch (...) {
61637       {
61638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61639       };
61640     }
61641   }
61642
61643 }
61644
61645
61646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61648   Dali::Toolkit::StyleManager arg2 ;
61649   Dali::StyleChange::Type arg3 ;
61650   Dali::Toolkit::StyleManager *argp2 ;
61651
61652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61653   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61654   if (!argp2) {
61655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61656     return ;
61657   }
61658   arg2 = *argp2;
61659   arg3 = (Dali::StyleChange::Type)jarg3;
61660   {
61661     try {
61662       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61663     } catch (std::out_of_range& e) {
61664       {
61665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61666       };
61667     } catch (std::exception& e) {
61668       {
61669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61670       };
61671     } catch (Dali::DaliException e) {
61672       {
61673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61674       };
61675     } catch (...) {
61676       {
61677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61678       };
61679     }
61680   }
61681
61682 }
61683
61684
61685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61686   unsigned int jresult ;
61687   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61688   bool result;
61689
61690   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61691   {
61692     try {
61693       result = (bool)(arg1)->OnAccessibilityActivated();
61694     } catch (std::out_of_range& e) {
61695       {
61696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61697       };
61698     } catch (std::exception& e) {
61699       {
61700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61701       };
61702     } catch (Dali::DaliException e) {
61703       {
61704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61705       };
61706     } catch (...) {
61707       {
61708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61709       };
61710     }
61711   }
61712
61713   jresult = result;
61714   return jresult;
61715 }
61716
61717
61718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61719   unsigned int jresult ;
61720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61721   bool result;
61722
61723   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61724   {
61725     try {
61726       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61727     } catch (std::out_of_range& e) {
61728       {
61729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61730       };
61731     } catch (std::exception& e) {
61732       {
61733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61734       };
61735     } catch (Dali::DaliException e) {
61736       {
61737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61738       };
61739     } catch (...) {
61740       {
61741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61742       };
61743     }
61744   }
61745
61746   jresult = result;
61747   return jresult;
61748 }
61749
61750
61751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61752   unsigned int jresult ;
61753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61754   Dali::PanGesture arg2 ;
61755   Dali::PanGesture *argp2 ;
61756   bool result;
61757
61758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61759   argp2 = (Dali::PanGesture *)jarg2;
61760   if (!argp2) {
61761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61762     return 0;
61763   }
61764   arg2 = *argp2;
61765   {
61766     try {
61767       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61768     } catch (std::out_of_range& e) {
61769       {
61770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61771       };
61772     } catch (std::exception& e) {
61773       {
61774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61775       };
61776     } catch (Dali::DaliException e) {
61777       {
61778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61779       };
61780     } catch (...) {
61781       {
61782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61783       };
61784     }
61785   }
61786
61787   jresult = result;
61788   return jresult;
61789 }
61790
61791
61792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61793   unsigned int jresult ;
61794   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61795   Dali::PanGesture arg2 ;
61796   Dali::PanGesture *argp2 ;
61797   bool result;
61798
61799   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61800   argp2 = (Dali::PanGesture *)jarg2;
61801   if (!argp2) {
61802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61803     return 0;
61804   }
61805   arg2 = *argp2;
61806   {
61807     try {
61808       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61809     } catch (std::out_of_range& e) {
61810       {
61811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61812       };
61813     } catch (std::exception& e) {
61814       {
61815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61816       };
61817     } catch (Dali::DaliException e) {
61818       {
61819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61820       };
61821     } catch (...) {
61822       {
61823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61824       };
61825     }
61826   }
61827
61828   jresult = result;
61829   return jresult;
61830 }
61831
61832
61833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61834   unsigned int jresult ;
61835   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61836   Dali::TouchEvent *arg2 = 0 ;
61837   bool result;
61838
61839   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61840   arg2 = (Dali::TouchEvent *)jarg2;
61841   if (!arg2) {
61842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61843     return 0;
61844   }
61845   {
61846     try {
61847       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61848     } catch (std::out_of_range& e) {
61849       {
61850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61851       };
61852     } catch (std::exception& e) {
61853       {
61854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61855       };
61856     } catch (Dali::DaliException e) {
61857       {
61858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61859       };
61860     } catch (...) {
61861       {
61862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61863       };
61864     }
61865   }
61866
61867   jresult = result;
61868   return jresult;
61869 }
61870
61871
61872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61873   unsigned int jresult ;
61874   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61875   Dali::TouchEvent *arg2 = 0 ;
61876   bool result;
61877
61878   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61879   arg2 = (Dali::TouchEvent *)jarg2;
61880   if (!arg2) {
61881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61882     return 0;
61883   }
61884   {
61885     try {
61886       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61887     } catch (std::out_of_range& e) {
61888       {
61889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61890       };
61891     } catch (std::exception& e) {
61892       {
61893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61894       };
61895     } catch (Dali::DaliException e) {
61896       {
61897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61898       };
61899     } catch (...) {
61900       {
61901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61902       };
61903     }
61904   }
61905
61906   jresult = result;
61907   return jresult;
61908 }
61909
61910
61911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61912   unsigned int jresult ;
61913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61914   bool arg2 ;
61915   bool result;
61916
61917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61918   arg2 = jarg2 ? true : false;
61919   {
61920     try {
61921       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61922     } catch (std::out_of_range& e) {
61923       {
61924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61925       };
61926     } catch (std::exception& e) {
61927       {
61928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61929       };
61930     } catch (Dali::DaliException e) {
61931       {
61932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61933       };
61934     } catch (...) {
61935       {
61936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61937       };
61938     }
61939   }
61940
61941   jresult = result;
61942   return jresult;
61943 }
61944
61945
61946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61947   unsigned int jresult ;
61948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61949   bool arg2 ;
61950   bool result;
61951
61952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61953   arg2 = jarg2 ? true : false;
61954   {
61955     try {
61956       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61957     } catch (std::out_of_range& e) {
61958       {
61959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61960       };
61961     } catch (std::exception& e) {
61962       {
61963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61964       };
61965     } catch (Dali::DaliException e) {
61966       {
61967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61968       };
61969     } catch (...) {
61970       {
61971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61972       };
61973     }
61974   }
61975
61976   jresult = result;
61977   return jresult;
61978 }
61979
61980
61981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61982   unsigned int jresult ;
61983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61984   bool result;
61985
61986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61987   {
61988     try {
61989       result = (bool)(arg1)->OnAccessibilityZoom();
61990     } catch (std::out_of_range& e) {
61991       {
61992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61993       };
61994     } catch (std::exception& e) {
61995       {
61996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61997       };
61998     } catch (Dali::DaliException e) {
61999       {
62000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62001       };
62002     } catch (...) {
62003       {
62004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62005       };
62006     }
62007   }
62008
62009   jresult = result;
62010   return jresult;
62011 }
62012
62013
62014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62015   unsigned int jresult ;
62016   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62017   bool result;
62018
62019   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62020   {
62021     try {
62022       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62023     } catch (std::out_of_range& e) {
62024       {
62025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62026       };
62027     } catch (std::exception& e) {
62028       {
62029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62030       };
62031     } catch (Dali::DaliException e) {
62032       {
62033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62034       };
62035     } catch (...) {
62036       {
62037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62038       };
62039     }
62040   }
62041
62042   jresult = result;
62043   return jresult;
62044 }
62045
62046
62047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62048   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62049
62050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62051   {
62052     try {
62053       (arg1)->OnKeyInputFocusGained();
62054     } catch (std::out_of_range& e) {
62055       {
62056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62057       };
62058     } catch (std::exception& e) {
62059       {
62060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62061       };
62062     } catch (Dali::DaliException e) {
62063       {
62064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62065       };
62066     } catch (...) {
62067       {
62068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62069       };
62070     }
62071   }
62072
62073 }
62074
62075
62076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62078
62079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62080   {
62081     try {
62082       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62083     } catch (std::out_of_range& e) {
62084       {
62085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62086       };
62087     } catch (std::exception& e) {
62088       {
62089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62090       };
62091     } catch (Dali::DaliException e) {
62092       {
62093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62094       };
62095     } catch (...) {
62096       {
62097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62098       };
62099     }
62100   }
62101
62102 }
62103
62104
62105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62107
62108   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62109   {
62110     try {
62111       (arg1)->OnKeyInputFocusLost();
62112     } catch (std::out_of_range& e) {
62113       {
62114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62115       };
62116     } catch (std::exception& e) {
62117       {
62118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62119       };
62120     } catch (Dali::DaliException e) {
62121       {
62122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62123       };
62124     } catch (...) {
62125       {
62126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62127       };
62128     }
62129   }
62130
62131 }
62132
62133
62134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62135   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62136
62137   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62138   {
62139     try {
62140       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62141     } catch (std::out_of_range& e) {
62142       {
62143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62144       };
62145     } catch (std::exception& e) {
62146       {
62147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62148       };
62149     } catch (Dali::DaliException e) {
62150       {
62151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62152       };
62153     } catch (...) {
62154       {
62155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62156       };
62157     }
62158   }
62159
62160 }
62161
62162
62163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62164   void * jresult ;
62165   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62166   Dali::Actor arg2 ;
62167   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62168   bool arg4 ;
62169   Dali::Actor *argp2 ;
62170   Dali::Actor result;
62171
62172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62173   argp2 = (Dali::Actor *)jarg2;
62174   if (!argp2) {
62175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62176     return 0;
62177   }
62178   arg2 = *argp2;
62179   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62180   arg4 = jarg4 ? true : false;
62181   {
62182     try {
62183       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62184     } catch (std::out_of_range& e) {
62185       {
62186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62187       };
62188     } catch (std::exception& e) {
62189       {
62190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62191       };
62192     } catch (Dali::DaliException e) {
62193       {
62194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62195       };
62196     } catch (...) {
62197       {
62198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62199       };
62200     }
62201   }
62202
62203   jresult = new Dali::Actor((const Dali::Actor &)result);
62204   return jresult;
62205 }
62206
62207
62208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62209   void * jresult ;
62210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62211   Dali::Actor arg2 ;
62212   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62213   bool arg4 ;
62214   Dali::Actor *argp2 ;
62215   Dali::Actor result;
62216
62217   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62218   argp2 = (Dali::Actor *)jarg2;
62219   if (!argp2) {
62220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62221     return 0;
62222   }
62223   arg2 = *argp2;
62224   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62225   arg4 = jarg4 ? true : false;
62226   {
62227     try {
62228       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62229     } catch (std::out_of_range& e) {
62230       {
62231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62232       };
62233     } catch (std::exception& e) {
62234       {
62235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62236       };
62237     } catch (Dali::DaliException e) {
62238       {
62239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62240       };
62241     } catch (...) {
62242       {
62243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62244       };
62245     }
62246   }
62247
62248   jresult = new Dali::Actor((const Dali::Actor &)result);
62249   return jresult;
62250 }
62251
62252
62253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62255   Dali::Actor arg2 ;
62256   Dali::Actor *argp2 ;
62257
62258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62259   argp2 = (Dali::Actor *)jarg2;
62260   if (!argp2) {
62261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62262     return ;
62263   }
62264   arg2 = *argp2;
62265   {
62266     try {
62267       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62268     } catch (std::out_of_range& e) {
62269       {
62270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62271       };
62272     } catch (std::exception& e) {
62273       {
62274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62275       };
62276     } catch (Dali::DaliException e) {
62277       {
62278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62279       };
62280     } catch (...) {
62281       {
62282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62283       };
62284     }
62285   }
62286
62287 }
62288
62289
62290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62292   Dali::Actor arg2 ;
62293   Dali::Actor *argp2 ;
62294
62295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62296   argp2 = (Dali::Actor *)jarg2;
62297   if (!argp2) {
62298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62299     return ;
62300   }
62301   arg2 = *argp2;
62302   {
62303     try {
62304       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62305     } catch (std::out_of_range& e) {
62306       {
62307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62308       };
62309     } catch (std::exception& e) {
62310       {
62311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62312       };
62313     } catch (Dali::DaliException e) {
62314       {
62315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62316       };
62317     } catch (...) {
62318       {
62319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62320       };
62321     }
62322   }
62323
62324 }
62325
62326
62327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62328   unsigned int jresult ;
62329   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62330   bool result;
62331
62332   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62333   {
62334     try {
62335       result = (bool)(arg1)->OnKeyboardEnter();
62336     } catch (std::out_of_range& e) {
62337       {
62338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62339       };
62340     } catch (std::exception& e) {
62341       {
62342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62343       };
62344     } catch (Dali::DaliException e) {
62345       {
62346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62347       };
62348     } catch (...) {
62349       {
62350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62351       };
62352     }
62353   }
62354
62355   jresult = result;
62356   return jresult;
62357 }
62358
62359
62360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62361   unsigned int jresult ;
62362   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62363   bool result;
62364
62365   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62366   {
62367     try {
62368       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62369     } catch (std::out_of_range& e) {
62370       {
62371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62372       };
62373     } catch (std::exception& e) {
62374       {
62375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62376       };
62377     } catch (Dali::DaliException e) {
62378       {
62379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62380       };
62381     } catch (...) {
62382       {
62383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62384       };
62385     }
62386   }
62387
62388   jresult = result;
62389   return jresult;
62390 }
62391
62392
62393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62394   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62395   Dali::PinchGesture *arg2 = 0 ;
62396
62397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62398   arg2 = (Dali::PinchGesture *)jarg2;
62399   if (!arg2) {
62400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62401     return ;
62402   }
62403   {
62404     try {
62405       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62406     } catch (std::out_of_range& e) {
62407       {
62408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62409       };
62410     } catch (std::exception& e) {
62411       {
62412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62413       };
62414     } catch (Dali::DaliException e) {
62415       {
62416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62417       };
62418     } catch (...) {
62419       {
62420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62421       };
62422     }
62423   }
62424
62425 }
62426
62427
62428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62429   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62430   Dali::PinchGesture *arg2 = 0 ;
62431
62432   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62433   arg2 = (Dali::PinchGesture *)jarg2;
62434   if (!arg2) {
62435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62436     return ;
62437   }
62438   {
62439     try {
62440       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62441     } catch (std::out_of_range& e) {
62442       {
62443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62444       };
62445     } catch (std::exception& e) {
62446       {
62447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62448       };
62449     } catch (Dali::DaliException e) {
62450       {
62451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62452       };
62453     } catch (...) {
62454       {
62455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62456       };
62457     }
62458   }
62459
62460 }
62461
62462
62463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62465   Dali::PanGesture *arg2 = 0 ;
62466
62467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62468   arg2 = (Dali::PanGesture *)jarg2;
62469   if (!arg2) {
62470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62471     return ;
62472   }
62473   {
62474     try {
62475       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62476     } catch (std::out_of_range& e) {
62477       {
62478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62479       };
62480     } catch (std::exception& e) {
62481       {
62482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62483       };
62484     } catch (Dali::DaliException e) {
62485       {
62486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62487       };
62488     } catch (...) {
62489       {
62490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62491       };
62492     }
62493   }
62494
62495 }
62496
62497
62498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62500   Dali::PanGesture *arg2 = 0 ;
62501
62502   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62503   arg2 = (Dali::PanGesture *)jarg2;
62504   if (!arg2) {
62505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62506     return ;
62507   }
62508   {
62509     try {
62510       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62511     } catch (std::out_of_range& e) {
62512       {
62513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62514       };
62515     } catch (std::exception& e) {
62516       {
62517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62518       };
62519     } catch (Dali::DaliException e) {
62520       {
62521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62522       };
62523     } catch (...) {
62524       {
62525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62526       };
62527     }
62528   }
62529
62530 }
62531
62532
62533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62535   Dali::TapGesture *arg2 = 0 ;
62536
62537   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62538   arg2 = (Dali::TapGesture *)jarg2;
62539   if (!arg2) {
62540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62541     return ;
62542   }
62543   {
62544     try {
62545       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62546     } catch (std::out_of_range& e) {
62547       {
62548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62549       };
62550     } catch (std::exception& e) {
62551       {
62552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62553       };
62554     } catch (Dali::DaliException e) {
62555       {
62556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62557       };
62558     } catch (...) {
62559       {
62560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62561       };
62562     }
62563   }
62564
62565 }
62566
62567
62568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62570   Dali::TapGesture *arg2 = 0 ;
62571
62572   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62573   arg2 = (Dali::TapGesture *)jarg2;
62574   if (!arg2) {
62575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62576     return ;
62577   }
62578   {
62579     try {
62580       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62581     } catch (std::out_of_range& e) {
62582       {
62583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62584       };
62585     } catch (std::exception& e) {
62586       {
62587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62588       };
62589     } catch (Dali::DaliException e) {
62590       {
62591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62592       };
62593     } catch (...) {
62594       {
62595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62596       };
62597     }
62598   }
62599
62600 }
62601
62602
62603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62604   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62605   Dali::LongPressGesture *arg2 = 0 ;
62606
62607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62608   arg2 = (Dali::LongPressGesture *)jarg2;
62609   if (!arg2) {
62610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62611     return ;
62612   }
62613   {
62614     try {
62615       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62616     } catch (std::out_of_range& e) {
62617       {
62618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62619       };
62620     } catch (std::exception& e) {
62621       {
62622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62623       };
62624     } catch (Dali::DaliException e) {
62625       {
62626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62627       };
62628     } catch (...) {
62629       {
62630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62631       };
62632     }
62633   }
62634
62635 }
62636
62637
62638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62639   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62640   Dali::LongPressGesture *arg2 = 0 ;
62641
62642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62643   arg2 = (Dali::LongPressGesture *)jarg2;
62644   if (!arg2) {
62645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62646     return ;
62647   }
62648   {
62649     try {
62650       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62651     } catch (std::out_of_range& e) {
62652       {
62653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62654       };
62655     } catch (std::exception& e) {
62656       {
62657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62658       };
62659     } catch (Dali::DaliException e) {
62660       {
62661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62662       };
62663     } catch (...) {
62664       {
62665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62666       };
62667     }
62668   }
62669
62670 }
62671
62672
62673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62674   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62675   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62676   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62677
62678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62679   arg2 = (Dali::SlotObserver *)jarg2;
62680   arg3 = (Dali::CallbackBase *)jarg3;
62681   {
62682     try {
62683       (arg1)->SignalConnected(arg2,arg3);
62684     } catch (std::out_of_range& e) {
62685       {
62686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62687       };
62688     } catch (std::exception& e) {
62689       {
62690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62691       };
62692     } catch (Dali::DaliException e) {
62693       {
62694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62695       };
62696     } catch (...) {
62697       {
62698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62699       };
62700     }
62701   }
62702
62703 }
62704
62705
62706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62707   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62708   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62709   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62710
62711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62712   arg2 = (Dali::SlotObserver *)jarg2;
62713   arg3 = (Dali::CallbackBase *)jarg3;
62714   {
62715     try {
62716       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62717     } catch (std::out_of_range& e) {
62718       {
62719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62720       };
62721     } catch (std::exception& e) {
62722       {
62723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62724       };
62725     } catch (Dali::DaliException e) {
62726       {
62727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62728       };
62729     } catch (...) {
62730       {
62731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62732       };
62733     }
62734   }
62735
62736 }
62737
62738
62739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62740   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62741   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62742   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62743
62744   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62745   arg2 = (Dali::SlotObserver *)jarg2;
62746   arg3 = (Dali::CallbackBase *)jarg3;
62747   {
62748     try {
62749       (arg1)->SignalDisconnected(arg2,arg3);
62750     } catch (std::out_of_range& e) {
62751       {
62752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62753       };
62754     } catch (std::exception& e) {
62755       {
62756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62757       };
62758     } catch (Dali::DaliException e) {
62759       {
62760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62761       };
62762     } catch (...) {
62763       {
62764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62765       };
62766     }
62767   }
62768
62769 }
62770
62771
62772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62773   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62774   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62775   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62776
62777   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62778   arg2 = (Dali::SlotObserver *)jarg2;
62779   arg3 = (Dali::CallbackBase *)jarg3;
62780   {
62781     try {
62782       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62783     } catch (std::out_of_range& e) {
62784       {
62785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62786       };
62787     } catch (std::exception& e) {
62788       {
62789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62790       };
62791     } catch (Dali::DaliException e) {
62792       {
62793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62794       };
62795     } catch (...) {
62796       {
62797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62798       };
62799     }
62800   }
62801
62802 }
62803
62804
62805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_director_connect(void *objarg, SwigDirector_ViewImpl::SWIG_Callback0_t callback0, SwigDirector_ViewImpl::SWIG_Callback1_t callback1, SwigDirector_ViewImpl::SWIG_Callback2_t callback2, SwigDirector_ViewImpl::SWIG_Callback3_t callback3, SwigDirector_ViewImpl::SWIG_Callback4_t callback4, SwigDirector_ViewImpl::SWIG_Callback5_t callback5, SwigDirector_ViewImpl::SWIG_Callback6_t callback6, SwigDirector_ViewImpl::SWIG_Callback7_t callback7, SwigDirector_ViewImpl::SWIG_Callback8_t callback8, SwigDirector_ViewImpl::SWIG_Callback9_t callback9, SwigDirector_ViewImpl::SWIG_Callback10_t callback10, SwigDirector_ViewImpl::SWIG_Callback11_t callback11, SwigDirector_ViewImpl::SWIG_Callback12_t callback12, SwigDirector_ViewImpl::SWIG_Callback13_t callback13, SwigDirector_ViewImpl::SWIG_Callback14_t callback14, SwigDirector_ViewImpl::SWIG_Callback15_t callback15, SwigDirector_ViewImpl::SWIG_Callback16_t callback16, SwigDirector_ViewImpl::SWIG_Callback17_t callback17, SwigDirector_ViewImpl::SWIG_Callback18_t callback18, SwigDirector_ViewImpl::SWIG_Callback19_t callback19, SwigDirector_ViewImpl::SWIG_Callback20_t callback20, SwigDirector_ViewImpl::SWIG_Callback21_t callback21, SwigDirector_ViewImpl::SWIG_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, SwigDirector_ViewImpl::SWIG_Callback27_t callback27, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) {
62806   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62807   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62808   if (director) {
62809     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback24, callback25, callback26, callback27, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
62810   }
62811 }
62812
62813
62814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62815   void * jresult ;
62816   Dali::Toolkit::Control *arg1 = 0 ;
62817   Dali::Toolkit::Internal::Control *result = 0 ;
62818
62819   arg1 = (Dali::Toolkit::Control *)jarg1;
62820   if (!arg1) {
62821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62822     return 0;
62823   }
62824   {
62825     try {
62826       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62827     } catch (std::out_of_range& e) {
62828       {
62829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62830       };
62831     } catch (std::exception& e) {
62832       {
62833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62834       };
62835     } catch (Dali::DaliException e) {
62836       {
62837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62838       };
62839     } catch (...) {
62840       {
62841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62842       };
62843     }
62844   }
62845
62846   jresult = (void *)result;
62847   return jresult;
62848 }
62849
62850
62851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62852   int jresult ;
62853   int result;
62854
62855   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62856   jresult = (int)result;
62857   return jresult;
62858 }
62859
62860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62861   int jresult ;
62862   int result;
62863
62864   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62865   jresult = (int)result;
62866   return jresult;
62867 }
62868
62869
62870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62871   int jresult ;
62872   int result;
62873
62874   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62875   jresult = (int)result;
62876   return jresult;
62877 }
62878
62879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
62880   int jresult ;
62881   int result;
62882
62883   result = (int)Dali::Toolkit::Control::Property::MARGIN;
62884   jresult = (int)result;
62885   return jresult;
62886 }
62887
62888
62889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
62890   int jresult ;
62891   int result;
62892
62893   result = (int)Dali::Toolkit::Control::Property::PADDING;
62894   jresult = (int)result;
62895   return jresult;
62896 }
62897
62898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
62899   int jresult ;
62900   int result;
62901
62902   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
62903   jresult = (int)result;
62904   return jresult;
62905 }
62906
62907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62908   void * jresult ;
62909   Dali::Toolkit::Control::Property *result = 0 ;
62910
62911   {
62912     try {
62913       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62914     } catch (std::out_of_range& e) {
62915       {
62916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62917       };
62918     } catch (std::exception& e) {
62919       {
62920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62921       };
62922     } catch (Dali::DaliException e) {
62923       {
62924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62925       };
62926     } catch (...) {
62927       {
62928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62929       };
62930     }
62931   }
62932
62933   jresult = (void *)result;
62934   return jresult;
62935 }
62936
62937
62938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62939   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62940
62941   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62942   {
62943     try {
62944       delete arg1;
62945     } catch (std::out_of_range& e) {
62946       {
62947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62948       };
62949     } catch (std::exception& e) {
62950       {
62951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62952       };
62953     } catch (Dali::DaliException e) {
62954       {
62955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62956       };
62957     } catch (...) {
62958       {
62959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62960       };
62961     }
62962   }
62963
62964 }
62965
62966
62967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62968   void * jresult ;
62969   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62970
62971   {
62972     try {
62973       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62974     } catch (std::out_of_range& e) {
62975       {
62976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62977       };
62978     } catch (std::exception& e) {
62979       {
62980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62981       };
62982     } catch (Dali::DaliException e) {
62983       {
62984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62985       };
62986     } catch (...) {
62987       {
62988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62989       };
62990     }
62991   }
62992
62993   jresult = (void *)result;
62994   return jresult;
62995 }
62996
62997
62998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62999   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63000
63001   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63002   {
63003     try {
63004       delete arg1;
63005     } catch (std::out_of_range& e) {
63006       {
63007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63008       };
63009     } catch (std::exception& e) {
63010       {
63011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63012       };
63013     } catch (Dali::DaliException e) {
63014       {
63015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63016       };
63017     } catch (...) {
63018       {
63019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63020       };
63021     }
63022   }
63023
63024 }
63025
63026
63027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63028   void * jresult ;
63029   Dali::Toolkit::Control result;
63030
63031   {
63032     try {
63033       result = Dali::Toolkit::Control::New();
63034     } catch (std::out_of_range& e) {
63035       {
63036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63037       };
63038     } catch (std::exception& e) {
63039       {
63040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63041       };
63042     } catch (Dali::DaliException e) {
63043       {
63044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63045       };
63046     } catch (...) {
63047       {
63048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63049       };
63050     }
63051   }
63052
63053   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63054   return jresult;
63055 }
63056
63057
63058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63059   void * jresult ;
63060   Dali::Toolkit::Control *result = 0 ;
63061
63062   {
63063     try {
63064       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63065     } catch (std::out_of_range& e) {
63066       {
63067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63068       };
63069     } catch (std::exception& e) {
63070       {
63071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63072       };
63073     } catch (Dali::DaliException e) {
63074       {
63075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63076       };
63077     } catch (...) {
63078       {
63079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63080       };
63081     }
63082   }
63083
63084   jresult = (void *)result;
63085   return jresult;
63086 }
63087
63088
63089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63090   void * jresult ;
63091   Dali::Toolkit::Control *arg1 = 0 ;
63092   Dali::Toolkit::Control *result = 0 ;
63093
63094   arg1 = (Dali::Toolkit::Control *)jarg1;
63095   if (!arg1) {
63096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63097     return 0;
63098   }
63099   {
63100     try {
63101       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63102     } catch (std::out_of_range& e) {
63103       {
63104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63105       };
63106     } catch (std::exception& e) {
63107       {
63108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63109       };
63110     } catch (Dali::DaliException e) {
63111       {
63112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63113       };
63114     } catch (...) {
63115       {
63116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63117       };
63118     }
63119   }
63120
63121   jresult = (void *)result;
63122   return jresult;
63123 }
63124
63125
63126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63127   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63128
63129   arg1 = (Dali::Toolkit::Control *)jarg1;
63130   {
63131     try {
63132       delete arg1;
63133     } catch (std::out_of_range& e) {
63134       {
63135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63136       };
63137     } catch (std::exception& e) {
63138       {
63139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63140       };
63141     } catch (Dali::DaliException e) {
63142       {
63143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63144       };
63145     } catch (...) {
63146       {
63147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63148       };
63149     }
63150   }
63151
63152 }
63153
63154
63155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63156   void * jresult ;
63157   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63158   Dali::Toolkit::Control *arg2 = 0 ;
63159   Dali::Toolkit::Control *result = 0 ;
63160
63161   arg1 = (Dali::Toolkit::Control *)jarg1;
63162   arg2 = (Dali::Toolkit::Control *)jarg2;
63163   if (!arg2) {
63164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63165     return 0;
63166   }
63167   {
63168     try {
63169       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63170     } catch (std::out_of_range& e) {
63171       {
63172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63173       };
63174     } catch (std::exception& e) {
63175       {
63176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63177       };
63178     } catch (Dali::DaliException e) {
63179       {
63180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63181       };
63182     } catch (...) {
63183       {
63184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63185       };
63186     }
63187   }
63188
63189   jresult = (void *)result;
63190   return jresult;
63191 }
63192
63193
63194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63195   void * jresult ;
63196   Dali::BaseHandle arg1 ;
63197   Dali::BaseHandle *argp1 ;
63198   Dali::Toolkit::Control result;
63199
63200   argp1 = (Dali::BaseHandle *)jarg1;
63201   if (!argp1) {
63202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63203     return 0;
63204   }
63205   arg1 = *argp1;
63206   {
63207     try {
63208       result = Dali::Toolkit::Control::DownCast(arg1);
63209     } catch (std::out_of_range& e) {
63210       {
63211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63212       };
63213     } catch (std::exception& e) {
63214       {
63215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63216       };
63217     } catch (Dali::DaliException e) {
63218       {
63219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63220       };
63221     } catch (...) {
63222       {
63223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63224       };
63225     }
63226   }
63227
63228   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63229   return jresult;
63230 }
63231
63232
63233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63234   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63235
63236   arg1 = (Dali::Toolkit::Control *)jarg1;
63237   {
63238     try {
63239       (arg1)->SetKeyInputFocus();
63240     } catch (std::out_of_range& e) {
63241       {
63242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63243       };
63244     } catch (std::exception& e) {
63245       {
63246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63247       };
63248     } catch (Dali::DaliException e) {
63249       {
63250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63251       };
63252     } catch (...) {
63253       {
63254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63255       };
63256     }
63257   }
63258
63259 }
63260
63261
63262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63263   unsigned int jresult ;
63264   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63265   bool result;
63266
63267   arg1 = (Dali::Toolkit::Control *)jarg1;
63268   {
63269     try {
63270       result = (bool)(arg1)->HasKeyInputFocus();
63271     } catch (std::out_of_range& e) {
63272       {
63273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63274       };
63275     } catch (std::exception& e) {
63276       {
63277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63278       };
63279     } catch (Dali::DaliException e) {
63280       {
63281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63282       };
63283     } catch (...) {
63284       {
63285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63286       };
63287     }
63288   }
63289
63290   jresult = result;
63291   return jresult;
63292 }
63293
63294
63295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63296   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63297
63298   arg1 = (Dali::Toolkit::Control *)jarg1;
63299   {
63300     try {
63301       (arg1)->ClearKeyInputFocus();
63302     } catch (std::out_of_range& e) {
63303       {
63304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63305       };
63306     } catch (std::exception& e) {
63307       {
63308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63309       };
63310     } catch (Dali::DaliException e) {
63311       {
63312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63313       };
63314     } catch (...) {
63315       {
63316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63317       };
63318     }
63319   }
63320
63321 }
63322
63323
63324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63325   void * jresult ;
63326   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63327   Dali::PinchGestureDetector result;
63328
63329   arg1 = (Dali::Toolkit::Control *)jarg1;
63330   {
63331     try {
63332       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63333     } catch (std::out_of_range& e) {
63334       {
63335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63336       };
63337     } catch (std::exception& e) {
63338       {
63339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63340       };
63341     } catch (Dali::DaliException e) {
63342       {
63343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63344       };
63345     } catch (...) {
63346       {
63347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63348       };
63349     }
63350   }
63351
63352   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63353   return jresult;
63354 }
63355
63356
63357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63358   void * jresult ;
63359   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63360   Dali::PanGestureDetector result;
63361
63362   arg1 = (Dali::Toolkit::Control *)jarg1;
63363   {
63364     try {
63365       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63366     } catch (std::out_of_range& e) {
63367       {
63368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63369       };
63370     } catch (std::exception& e) {
63371       {
63372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63373       };
63374     } catch (Dali::DaliException e) {
63375       {
63376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63377       };
63378     } catch (...) {
63379       {
63380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63381       };
63382     }
63383   }
63384
63385   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63386   return jresult;
63387 }
63388
63389
63390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63391   void * jresult ;
63392   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63393   Dali::TapGestureDetector result;
63394
63395   arg1 = (Dali::Toolkit::Control *)jarg1;
63396   {
63397     try {
63398       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63399     } catch (std::out_of_range& e) {
63400       {
63401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63402       };
63403     } catch (std::exception& e) {
63404       {
63405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63406       };
63407     } catch (Dali::DaliException e) {
63408       {
63409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63410       };
63411     } catch (...) {
63412       {
63413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63414       };
63415     }
63416   }
63417
63418   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63419   return jresult;
63420 }
63421
63422
63423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63424   void * jresult ;
63425   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63426   Dali::LongPressGestureDetector result;
63427
63428   arg1 = (Dali::Toolkit::Control *)jarg1;
63429   {
63430     try {
63431       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63432     } catch (std::out_of_range& e) {
63433       {
63434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63435       };
63436     } catch (std::exception& e) {
63437       {
63438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63439       };
63440     } catch (Dali::DaliException e) {
63441       {
63442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63443       };
63444     } catch (...) {
63445       {
63446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63447       };
63448     }
63449   }
63450
63451   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63452   return jresult;
63453 }
63454
63455
63456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63457   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63458   std::string *arg2 = 0 ;
63459
63460   arg1 = (Dali::Toolkit::Control *)jarg1;
63461   if (!jarg2) {
63462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63463     return ;
63464   }
63465   std::string arg2_str(jarg2);
63466   arg2 = &arg2_str;
63467   {
63468     try {
63469       (arg1)->SetStyleName((std::string const &)*arg2);
63470     } catch (std::out_of_range& e) {
63471       {
63472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63473       };
63474     } catch (std::exception& e) {
63475       {
63476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63477       };
63478     } catch (Dali::DaliException e) {
63479       {
63480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63481       };
63482     } catch (...) {
63483       {
63484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63485       };
63486     }
63487   }
63488
63489
63490   //argout typemap for const std::string&
63491
63492 }
63493
63494
63495 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63496   char * jresult ;
63497   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63498   std::string *result = 0 ;
63499
63500   arg1 = (Dali::Toolkit::Control *)jarg1;
63501   {
63502     try {
63503       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63504     } catch (std::out_of_range& e) {
63505       {
63506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63507       };
63508     } catch (std::exception& e) {
63509       {
63510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63511       };
63512     } catch (Dali::DaliException e) {
63513       {
63514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63515       };
63516     } catch (...) {
63517       {
63518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63519       };
63520     }
63521   }
63522
63523   jresult = SWIG_csharp_string_callback(result->c_str());
63524   return jresult;
63525 }
63526
63527
63528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63529   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63530   Dali::Vector4 *arg2 = 0 ;
63531
63532   arg1 = (Dali::Toolkit::Control *)jarg1;
63533   arg2 = (Dali::Vector4 *)jarg2;
63534   if (!arg2) {
63535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63536     return ;
63537   }
63538   {
63539     try {
63540       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63541     } catch (std::out_of_range& e) {
63542       {
63543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63544       };
63545     } catch (std::exception& e) {
63546       {
63547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63548       };
63549     } catch (Dali::DaliException e) {
63550       {
63551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63552       };
63553     } catch (...) {
63554       {
63555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63556       };
63557     }
63558   }
63559
63560 }
63561
63562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63563   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63564
63565   arg1 = (Dali::Toolkit::Control *)jarg1;
63566   {
63567     try {
63568       (arg1)->ClearBackground();
63569     } catch (std::out_of_range& e) {
63570       {
63571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63572       };
63573     } catch (std::exception& e) {
63574       {
63575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63576       };
63577     } catch (Dali::DaliException e) {
63578       {
63579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63580       };
63581     } catch (...) {
63582       {
63583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63584       };
63585     }
63586   }
63587
63588 }
63589
63590
63591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63592   void * jresult ;
63593   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63594   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63595
63596   arg1 = (Dali::Toolkit::Control *)jarg1;
63597   {
63598     try {
63599       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63600     } catch (std::out_of_range& e) {
63601       {
63602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63603       };
63604     } catch (std::exception& e) {
63605       {
63606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63607       };
63608     } catch (Dali::DaliException e) {
63609       {
63610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63611       };
63612     } catch (...) {
63613       {
63614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63615       };
63616     }
63617   }
63618
63619   jresult = (void *)result;
63620   return jresult;
63621 }
63622
63623
63624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63625   void * jresult ;
63626   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63627   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63628
63629   arg1 = (Dali::Toolkit::Control *)jarg1;
63630   {
63631     try {
63632       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63633     } catch (std::out_of_range& e) {
63634       {
63635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63636       };
63637     } catch (std::exception& e) {
63638       {
63639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63640       };
63641     } catch (Dali::DaliException e) {
63642       {
63643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63644       };
63645     } catch (...) {
63646       {
63647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63648       };
63649     }
63650   }
63651
63652   jresult = (void *)result;
63653   return jresult;
63654 }
63655
63656
63657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63658   void * jresult ;
63659   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63660   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63661
63662   arg1 = (Dali::Toolkit::Control *)jarg1;
63663   {
63664     try {
63665       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63666     } catch (std::out_of_range& e) {
63667       {
63668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63669       };
63670     } catch (std::exception& e) {
63671       {
63672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63673       };
63674     } catch (Dali::DaliException e) {
63675       {
63676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63677       };
63678     } catch (...) {
63679       {
63680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63681       };
63682     }
63683   }
63684
63685   jresult = (void *)result;
63686   return jresult;
63687 }
63688
63689
63690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63691   void * jresult ;
63692   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63693   Dali::Toolkit::Control *result = 0 ;
63694
63695   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63696   if (!arg1) {
63697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63698     return 0;
63699   }
63700   {
63701     try {
63702       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63703     } catch (std::out_of_range& e) {
63704       {
63705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63706       };
63707     } catch (std::exception& e) {
63708       {
63709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63710       };
63711     } catch (Dali::DaliException e) {
63712       {
63713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63714       };
63715     } catch (...) {
63716       {
63717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63718       };
63719     }
63720   }
63721
63722   jresult = (void *)result;
63723   return jresult;
63724 }
63725
63726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
63727 {
63728   int jresult;
63729   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63730   arg1 = (Dali::Toolkit::Control *)jarg1;
63731
63732   if (!arg1) {
63733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63734     return 0;
63735   }
63736
63737   Dali::Property::Index arg2 = 0 ;
63738   arg2 = (Dali::Property::Index)jarg2;
63739
63740   Toolkit::Visual::ResourceStatus result;
63741   {
63742     try {
63743       result = arg1->GetVisualResourceStatus(arg2);
63744     } catch (std::out_of_range& e) {
63745       {
63746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63747       };
63748     } catch (std::exception& e) {
63749       {
63750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63751       };
63752     } catch (...) {
63753       {
63754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63755       };
63756     }
63757   }
63758   jresult = (int)(result);
63759   return jresult;
63760 }
63761
63762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
63763 {
63764   void * jresult;
63765   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63766   arg1 = (Dali::Toolkit::Control *)jarg1;
63767
63768   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
63769
63770   Dali::Toolkit::TransitionData *arg2 = 0 ;
63771   Dali::Animation result;
63772
63773   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
63774   if (!arg2) {
63775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
63776     return 0;
63777   }
63778   {
63779     try {
63780       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
63781     } catch (std::out_of_range& e) {
63782       {
63783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63784       };
63785     } catch (std::exception& e) {
63786       {
63787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63788       };
63789     } catch (Dali::DaliException e) {
63790       {
63791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63792       };
63793     } catch (...) {
63794       {
63795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63796       };
63797     }
63798   }
63799
63800   jresult = new Dali::Animation((const Dali::Animation &)result);
63801   return jresult;
63802 }
63803
63804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
63805 {
63806   Dali::Toolkit::Control arg1;
63807   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
63808
63809   if (!argp1) {
63810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63811   }
63812   arg1 = *argp1;
63813
63814   Dali::Property::Index arg2 = 0 ;
63815   arg2 = (Dali::Property::Index)jarg2;
63816
63817   Dali::Property::Index arg3 = 0 ;
63818   arg3 = (Dali::Property::Index)jarg3;
63819
63820   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
63821
63822   {
63823     try {
63824       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
63825     } catch (std::out_of_range& e) {
63826       {
63827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63828       };
63829     } catch (std::exception& e) {
63830       {
63831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63832       };
63833     } catch (...) {
63834       {
63835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63836       };
63837     }
63838   }
63839
63840
63841 }
63842
63843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
63844   void * jresult ;
63845   Dali::Toolkit::Control *arg1 = 0 ;
63846   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
63847
63848   arg1 = (Dali::Toolkit::Control *)jarg1;
63849   if (!arg1) {
63850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63851     return 0;
63852   }
63853   {
63854     try {
63855       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
63856     } catch (std::out_of_range& e) {
63857       {
63858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63859       };
63860     } catch (std::exception& e) {
63861       {
63862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63863       };
63864     } catch (Dali::DaliException e) {
63865       {
63866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63867       };
63868     } catch (...) {
63869       {
63870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63871       };
63872     }
63873   }
63874
63875   jresult = (void *)result;
63876   return jresult;
63877 }
63878
63879
63880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
63881   unsigned int jresult ;
63882   Dali::Toolkit::Control *arg1 = 0 ;
63883   bool result;
63884
63885   arg1 = (Dali::Toolkit::Control *)jarg1;
63886   if (!arg1) {
63887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63888     return 0;
63889   }
63890   {
63891     try {
63892       result = (bool)arg1->IsResourceReady();
63893     } catch (std::out_of_range& e) {
63894       {
63895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63896       };
63897     } catch (std::exception& e) {
63898       {
63899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63900       };
63901     } catch (Dali::DaliException e) {
63902       {
63903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63904       };
63905     } catch (...) {
63906       {
63907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63908       };
63909     }
63910   }
63911
63912   jresult = result;
63913   return jresult;
63914 }
63915
63916
63917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63918   void * jresult ;
63919   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63920
63921   {
63922     try {
63923       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63924     } catch (std::out_of_range& e) {
63925       {
63926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63927       };
63928     } catch (std::exception& e) {
63929       {
63930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63931       };
63932     } catch (Dali::DaliException e) {
63933       {
63934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63935       };
63936     } catch (...) {
63937       {
63938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63939       };
63940     }
63941   }
63942
63943   jresult = (void *)result;
63944   return jresult;
63945 }
63946
63947
63948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63949   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63950
63951   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63952   {
63953     try {
63954       delete arg1;
63955     } catch (std::out_of_range& e) {
63956       {
63957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63958       };
63959     } catch (std::exception& e) {
63960       {
63961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63962       };
63963     } catch (Dali::DaliException e) {
63964       {
63965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63966       };
63967     } catch (...) {
63968       {
63969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63970       };
63971     }
63972   }
63973
63974 }
63975
63976
63977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63978   void * jresult ;
63979   Dali::Toolkit::KeyInputFocusManager result;
63980
63981   {
63982     try {
63983       result = Dali::Toolkit::KeyInputFocusManager::Get();
63984     } catch (std::out_of_range& e) {
63985       {
63986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63987       };
63988     } catch (std::exception& e) {
63989       {
63990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63991       };
63992     } catch (Dali::DaliException e) {
63993       {
63994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63995       };
63996     } catch (...) {
63997       {
63998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63999       };
64000     }
64001   }
64002
64003   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64004   return jresult;
64005 }
64006
64007
64008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64009   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64010   Dali::Toolkit::Control arg2 ;
64011   Dali::Toolkit::Control *argp2 ;
64012
64013   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64014   argp2 = (Dali::Toolkit::Control *)jarg2;
64015   if (!argp2) {
64016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64017     return ;
64018   }
64019   arg2 = *argp2;
64020   {
64021     try {
64022       (arg1)->SetFocus(arg2);
64023     } catch (std::out_of_range& e) {
64024       {
64025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64026       };
64027     } catch (std::exception& e) {
64028       {
64029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64030       };
64031     } catch (Dali::DaliException e) {
64032       {
64033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64034       };
64035     } catch (...) {
64036       {
64037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64038       };
64039     }
64040   }
64041
64042 }
64043
64044
64045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64046   void * jresult ;
64047   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64048   Dali::Toolkit::Control result;
64049
64050   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64051   {
64052     try {
64053       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64054     } catch (std::out_of_range& e) {
64055       {
64056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64057       };
64058     } catch (std::exception& e) {
64059       {
64060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64061       };
64062     } catch (Dali::DaliException e) {
64063       {
64064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64065       };
64066     } catch (...) {
64067       {
64068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64069       };
64070     }
64071   }
64072
64073   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64074   return jresult;
64075 }
64076
64077
64078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64079   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64080   Dali::Toolkit::Control arg2 ;
64081   Dali::Toolkit::Control *argp2 ;
64082
64083   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64084   argp2 = (Dali::Toolkit::Control *)jarg2;
64085   if (!argp2) {
64086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64087     return ;
64088   }
64089   arg2 = *argp2;
64090   {
64091     try {
64092       (arg1)->RemoveFocus(arg2);
64093     } catch (std::out_of_range& e) {
64094       {
64095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64096       };
64097     } catch (std::exception& e) {
64098       {
64099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64100       };
64101     } catch (Dali::DaliException e) {
64102       {
64103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64104       };
64105     } catch (...) {
64106       {
64107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64108       };
64109     }
64110   }
64111
64112 }
64113
64114
64115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64116   void * jresult ;
64117   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64118   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64119
64120   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64121   {
64122     try {
64123       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64124     } catch (std::out_of_range& e) {
64125       {
64126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64127       };
64128     } catch (std::exception& e) {
64129       {
64130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64131       };
64132     } catch (Dali::DaliException e) {
64133       {
64134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64135       };
64136     } catch (...) {
64137       {
64138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64139       };
64140     }
64141   }
64142
64143   jresult = (void *)result;
64144   return jresult;
64145 }
64146
64147
64148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64149   void * jresult ;
64150   Dali::Toolkit::Alignment::Padding *result = 0 ;
64151
64152   {
64153     try {
64154       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64155     } catch (std::out_of_range& e) {
64156       {
64157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64158       };
64159     } catch (std::exception& e) {
64160       {
64161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64162       };
64163     } catch (Dali::DaliException e) {
64164       {
64165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64166       };
64167     } catch (...) {
64168       {
64169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64170       };
64171     }
64172   }
64173
64174   jresult = (void *)result;
64175   return jresult;
64176 }
64177
64178
64179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64180   void * jresult ;
64181   float arg1 ;
64182   float arg2 ;
64183   float arg3 ;
64184   float arg4 ;
64185   Dali::Toolkit::Alignment::Padding *result = 0 ;
64186
64187   arg1 = (float)jarg1;
64188   arg2 = (float)jarg2;
64189   arg3 = (float)jarg3;
64190   arg4 = (float)jarg4;
64191   {
64192     try {
64193       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64194     } catch (std::out_of_range& e) {
64195       {
64196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64197       };
64198     } catch (std::exception& e) {
64199       {
64200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64201       };
64202     } catch (Dali::DaliException e) {
64203       {
64204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64205       };
64206     } catch (...) {
64207       {
64208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64209       };
64210     }
64211   }
64212
64213   jresult = (void *)result;
64214   return jresult;
64215 }
64216
64217
64218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64219   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64220   float arg2 ;
64221
64222   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64223   arg2 = (float)jarg2;
64224   if (arg1) (arg1)->left = arg2;
64225 }
64226
64227
64228 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64229   float jresult ;
64230   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64231   float result;
64232
64233   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64234   result = (float) ((arg1)->left);
64235   jresult = result;
64236   return jresult;
64237 }
64238
64239
64240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64241   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64242   float arg2 ;
64243
64244   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64245   arg2 = (float)jarg2;
64246   if (arg1) (arg1)->right = arg2;
64247 }
64248
64249
64250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64251   float jresult ;
64252   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64253   float result;
64254
64255   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64256   result = (float) ((arg1)->right);
64257   jresult = result;
64258   return jresult;
64259 }
64260
64261
64262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64263   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64264   float arg2 ;
64265
64266   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64267   arg2 = (float)jarg2;
64268   if (arg1) (arg1)->top = arg2;
64269 }
64270
64271
64272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64273   float jresult ;
64274   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64275   float result;
64276
64277   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64278   result = (float) ((arg1)->top);
64279   jresult = result;
64280   return jresult;
64281 }
64282
64283
64284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64285   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64286   float arg2 ;
64287
64288   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64289   arg2 = (float)jarg2;
64290   if (arg1) (arg1)->bottom = arg2;
64291 }
64292
64293
64294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64295   float jresult ;
64296   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64297   float result;
64298
64299   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64300   result = (float) ((arg1)->bottom);
64301   jresult = result;
64302   return jresult;
64303 }
64304
64305
64306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64307   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64308
64309   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64310   {
64311     try {
64312       delete arg1;
64313     } catch (std::out_of_range& e) {
64314       {
64315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64316       };
64317     } catch (std::exception& e) {
64318       {
64319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64320       };
64321     } catch (Dali::DaliException e) {
64322       {
64323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64324       };
64325     } catch (...) {
64326       {
64327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64328       };
64329     }
64330   }
64331
64332 }
64333
64334
64335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64336   void * jresult ;
64337   Dali::Toolkit::Alignment *result = 0 ;
64338
64339   {
64340     try {
64341       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64342     } catch (std::out_of_range& e) {
64343       {
64344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64345       };
64346     } catch (std::exception& e) {
64347       {
64348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64349       };
64350     } catch (Dali::DaliException e) {
64351       {
64352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64353       };
64354     } catch (...) {
64355       {
64356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64357       };
64358     }
64359   }
64360
64361   jresult = (void *)result;
64362   return jresult;
64363 }
64364
64365
64366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64367   void * jresult ;
64368   Dali::Toolkit::Alignment::Type arg1 ;
64369   Dali::Toolkit::Alignment::Type arg2 ;
64370   Dali::Toolkit::Alignment result;
64371
64372   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64373   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64374   {
64375     try {
64376       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64377     } catch (std::out_of_range& e) {
64378       {
64379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64380       };
64381     } catch (std::exception& e) {
64382       {
64383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64384       };
64385     } catch (Dali::DaliException e) {
64386       {
64387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64388       };
64389     } catch (...) {
64390       {
64391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64392       };
64393     }
64394   }
64395
64396   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64397   return jresult;
64398 }
64399
64400
64401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64402   void * jresult ;
64403   Dali::Toolkit::Alignment::Type arg1 ;
64404   Dali::Toolkit::Alignment result;
64405
64406   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64407   {
64408     try {
64409       result = Dali::Toolkit::Alignment::New(arg1);
64410     } catch (std::out_of_range& e) {
64411       {
64412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64413       };
64414     } catch (std::exception& e) {
64415       {
64416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64417       };
64418     } catch (Dali::DaliException e) {
64419       {
64420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64421       };
64422     } catch (...) {
64423       {
64424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64425       };
64426     }
64427   }
64428
64429   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64430   return jresult;
64431 }
64432
64433
64434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64435   void * jresult ;
64436   Dali::Toolkit::Alignment result;
64437
64438   {
64439     try {
64440       result = Dali::Toolkit::Alignment::New();
64441     } catch (std::out_of_range& e) {
64442       {
64443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64444       };
64445     } catch (std::exception& e) {
64446       {
64447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64448       };
64449     } catch (Dali::DaliException e) {
64450       {
64451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64452       };
64453     } catch (...) {
64454       {
64455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64456       };
64457     }
64458   }
64459
64460   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64461   return jresult;
64462 }
64463
64464
64465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64466   void * jresult ;
64467   Dali::Toolkit::Alignment *arg1 = 0 ;
64468   Dali::Toolkit::Alignment *result = 0 ;
64469
64470   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64471   if (!arg1) {
64472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64473     return 0;
64474   }
64475   {
64476     try {
64477       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64478     } catch (std::out_of_range& e) {
64479       {
64480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64481       };
64482     } catch (std::exception& e) {
64483       {
64484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64485       };
64486     } catch (Dali::DaliException e) {
64487       {
64488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64489       };
64490     } catch (...) {
64491       {
64492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64493       };
64494     }
64495   }
64496
64497   jresult = (void *)result;
64498   return jresult;
64499 }
64500
64501
64502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64503   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64504
64505   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64506   {
64507     try {
64508       delete arg1;
64509     } catch (std::out_of_range& e) {
64510       {
64511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64512       };
64513     } catch (std::exception& e) {
64514       {
64515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64516       };
64517     } catch (Dali::DaliException e) {
64518       {
64519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64520       };
64521     } catch (...) {
64522       {
64523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64524       };
64525     }
64526   }
64527
64528 }
64529
64530
64531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64532   void * jresult ;
64533   Dali::BaseHandle arg1 ;
64534   Dali::BaseHandle *argp1 ;
64535   Dali::Toolkit::Alignment result;
64536
64537   argp1 = (Dali::BaseHandle *)jarg1;
64538   if (!argp1) {
64539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64540     return 0;
64541   }
64542   arg1 = *argp1;
64543   {
64544     try {
64545       result = Dali::Toolkit::Alignment::DownCast(arg1);
64546     } catch (std::out_of_range& e) {
64547       {
64548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64549       };
64550     } catch (std::exception& e) {
64551       {
64552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64553       };
64554     } catch (Dali::DaliException e) {
64555       {
64556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64557       };
64558     } catch (...) {
64559       {
64560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64561       };
64562     }
64563   }
64564
64565   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64566   return jresult;
64567 }
64568
64569
64570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64571   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64572   Dali::Toolkit::Alignment::Type arg2 ;
64573
64574   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64575   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64576   {
64577     try {
64578       (arg1)->SetAlignmentType(arg2);
64579     } catch (std::out_of_range& e) {
64580       {
64581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64582       };
64583     } catch (std::exception& e) {
64584       {
64585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64586       };
64587     } catch (Dali::DaliException e) {
64588       {
64589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64590       };
64591     } catch (...) {
64592       {
64593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64594       };
64595     }
64596   }
64597
64598 }
64599
64600
64601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64602   int jresult ;
64603   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64604   Dali::Toolkit::Alignment::Type result;
64605
64606   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64607   {
64608     try {
64609       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64610     } catch (std::out_of_range& e) {
64611       {
64612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64613       };
64614     } catch (std::exception& e) {
64615       {
64616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64617       };
64618     } catch (Dali::DaliException e) {
64619       {
64620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64621       };
64622     } catch (...) {
64623       {
64624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64625       };
64626     }
64627   }
64628
64629   jresult = (int)result;
64630   return jresult;
64631 }
64632
64633
64634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64635   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64636   Dali::Toolkit::Alignment::Scaling arg2 ;
64637
64638   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64639   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64640   {
64641     try {
64642       (arg1)->SetScaling(arg2);
64643     } catch (std::out_of_range& e) {
64644       {
64645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64646       };
64647     } catch (std::exception& e) {
64648       {
64649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64650       };
64651     } catch (Dali::DaliException e) {
64652       {
64653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64654       };
64655     } catch (...) {
64656       {
64657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64658       };
64659     }
64660   }
64661
64662 }
64663
64664
64665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64666   int jresult ;
64667   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64668   Dali::Toolkit::Alignment::Scaling result;
64669
64670   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64671   {
64672     try {
64673       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64674     } catch (std::out_of_range& e) {
64675       {
64676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64677       };
64678     } catch (std::exception& e) {
64679       {
64680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64681       };
64682     } catch (Dali::DaliException e) {
64683       {
64684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64685       };
64686     } catch (...) {
64687       {
64688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64689       };
64690     }
64691   }
64692
64693   jresult = (int)result;
64694   return jresult;
64695 }
64696
64697
64698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64699   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64700   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64701
64702   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64703   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64704   if (!arg2) {
64705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64706     return ;
64707   }
64708   {
64709     try {
64710       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64711     } catch (std::out_of_range& e) {
64712       {
64713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64714       };
64715     } catch (std::exception& e) {
64716       {
64717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64718       };
64719     } catch (Dali::DaliException e) {
64720       {
64721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64722       };
64723     } catch (...) {
64724       {
64725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64726       };
64727     }
64728   }
64729
64730 }
64731
64732
64733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64734   void * jresult ;
64735   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64736   Dali::Toolkit::Alignment::Padding *result = 0 ;
64737
64738   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64739   {
64740     try {
64741       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64742     } catch (std::out_of_range& e) {
64743       {
64744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64745       };
64746     } catch (std::exception& e) {
64747       {
64748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64749       };
64750     } catch (Dali::DaliException e) {
64751       {
64752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64753       };
64754     } catch (...) {
64755       {
64756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64757       };
64758     }
64759   }
64760
64761   jresult = (void *)result;
64762   return jresult;
64763 }
64764
64765
64766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64767   void * jresult ;
64768   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64769   Dali::Toolkit::Alignment *arg2 = 0 ;
64770   Dali::Toolkit::Alignment *result = 0 ;
64771
64772   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64773   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64774   if (!arg2) {
64775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64776     return 0;
64777   }
64778   {
64779     try {
64780       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64781     } catch (std::out_of_range& e) {
64782       {
64783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64784       };
64785     } catch (std::exception& e) {
64786       {
64787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64788       };
64789     } catch (Dali::DaliException e) {
64790       {
64791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64792       };
64793     } catch (...) {
64794       {
64795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64796       };
64797     }
64798   }
64799
64800   jresult = (void *)result;
64801   return jresult;
64802 }
64803
64804
64805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64806   int jresult ;
64807   int result;
64808
64809   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64810   jresult = (int)result;
64811   return jresult;
64812 }
64813
64814
64815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64816   int jresult ;
64817   int result;
64818
64819   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64820   jresult = (int)result;
64821   return jresult;
64822 }
64823
64824
64825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64826   int jresult ;
64827   int result;
64828
64829   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64830   jresult = (int)result;
64831   return jresult;
64832 }
64833
64834
64835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64836   int jresult ;
64837   int result;
64838
64839   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64840   jresult = (int)result;
64841   return jresult;
64842 }
64843
64844
64845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64846   int jresult ;
64847   int result;
64848
64849   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64850   jresult = (int)result;
64851   return jresult;
64852 }
64853
64854
64855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64856   int jresult ;
64857   int result;
64858
64859   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64860   jresult = (int)result;
64861   return jresult;
64862 }
64863
64864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64865   int jresult ;
64866   int result;
64867
64868   result = (int)Dali::Toolkit::Button::Property::LABEL;
64869   jresult = (int)result;
64870   return jresult;
64871 }
64872
64873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64874   void * jresult ;
64875   Dali::Toolkit::Button::Property *result = 0 ;
64876
64877   {
64878     try {
64879       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64880     } catch (std::out_of_range& e) {
64881       {
64882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64883       };
64884     } catch (std::exception& e) {
64885       {
64886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64887       };
64888     } catch (Dali::DaliException e) {
64889       {
64890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64891       };
64892     } catch (...) {
64893       {
64894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64895       };
64896     }
64897   }
64898
64899   jresult = (void *)result;
64900   return jresult;
64901 }
64902
64903
64904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64905   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64906
64907   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64908   {
64909     try {
64910       delete arg1;
64911     } catch (std::out_of_range& e) {
64912       {
64913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64914       };
64915     } catch (std::exception& e) {
64916       {
64917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64918       };
64919     } catch (Dali::DaliException e) {
64920       {
64921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64922       };
64923     } catch (...) {
64924       {
64925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64926       };
64927     }
64928   }
64929
64930 }
64931
64932
64933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
64934   void * jresult ;
64935   Dali::Toolkit::Button *result = 0 ;
64936
64937   {
64938     try {
64939       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64940     } catch (std::out_of_range& e) {
64941       {
64942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64943       };
64944     } catch (std::exception& e) {
64945       {
64946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64947       };
64948     } catch (Dali::DaliException e) {
64949       {
64950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64951       };
64952     } catch (...) {
64953       {
64954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64955       };
64956     }
64957   }
64958
64959   jresult = (void *)result;
64960   return jresult;
64961 }
64962
64963
64964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64965   void * jresult ;
64966   Dali::Toolkit::Button *arg1 = 0 ;
64967   Dali::Toolkit::Button *result = 0 ;
64968
64969   arg1 = (Dali::Toolkit::Button *)jarg1;
64970   if (!arg1) {
64971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64972     return 0;
64973   }
64974   {
64975     try {
64976       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64977     } catch (std::out_of_range& e) {
64978       {
64979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64980       };
64981     } catch (std::exception& e) {
64982       {
64983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64984       };
64985     } catch (Dali::DaliException e) {
64986       {
64987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64988       };
64989     } catch (...) {
64990       {
64991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64992       };
64993     }
64994   }
64995
64996   jresult = (void *)result;
64997   return jresult;
64998 }
64999
65000
65001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65002   void * jresult ;
65003   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65004   Dali::Toolkit::Button *arg2 = 0 ;
65005   Dali::Toolkit::Button *result = 0 ;
65006
65007   arg1 = (Dali::Toolkit::Button *)jarg1;
65008   arg2 = (Dali::Toolkit::Button *)jarg2;
65009   if (!arg2) {
65010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65011     return 0;
65012   }
65013   {
65014     try {
65015       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65016     } catch (std::out_of_range& e) {
65017       {
65018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65019       };
65020     } catch (std::exception& e) {
65021       {
65022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65023       };
65024     } catch (Dali::DaliException e) {
65025       {
65026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65027       };
65028     } catch (...) {
65029       {
65030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65031       };
65032     }
65033   }
65034
65035   jresult = (void *)result;
65036   return jresult;
65037 }
65038
65039
65040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65041   void * jresult ;
65042   Dali::BaseHandle arg1 ;
65043   Dali::BaseHandle *argp1 ;
65044   Dali::Toolkit::Button result;
65045
65046   argp1 = (Dali::BaseHandle *)jarg1;
65047   if (!argp1) {
65048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65049     return 0;
65050   }
65051   arg1 = *argp1;
65052   {
65053     try {
65054       result = Dali::Toolkit::Button::DownCast(arg1);
65055     } catch (std::out_of_range& e) {
65056       {
65057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65058       };
65059     } catch (std::exception& e) {
65060       {
65061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65062       };
65063     } catch (Dali::DaliException e) {
65064       {
65065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65066       };
65067     } catch (...) {
65068       {
65069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65070       };
65071     }
65072   }
65073
65074   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65075   return jresult;
65076 }
65077
65078
65079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65080   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65081
65082   arg1 = (Dali::Toolkit::Button *)jarg1;
65083   {
65084     try {
65085       delete arg1;
65086     } catch (std::out_of_range& e) {
65087       {
65088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65089       };
65090     } catch (std::exception& e) {
65091       {
65092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65093       };
65094     } catch (Dali::DaliException e) {
65095       {
65096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65097       };
65098     } catch (...) {
65099       {
65100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65101       };
65102     }
65103   }
65104
65105 }
65106
65107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65108   void * jresult ;
65109   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65110   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65111
65112   arg1 = (Dali::Toolkit::Button *)jarg1;
65113   {
65114     try {
65115       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65116     } catch (std::out_of_range& e) {
65117       {
65118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65119       };
65120     } catch (std::exception& e) {
65121       {
65122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65123       };
65124     } catch (Dali::DaliException e) {
65125       {
65126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65127       };
65128     } catch (...) {
65129       {
65130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65131       };
65132     }
65133   }
65134
65135   jresult = (void *)result;
65136   return jresult;
65137 }
65138
65139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65140   void * jresult ;
65141   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65142   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65143
65144   arg1 = (Dali::Toolkit::Button *)jarg1;
65145   {
65146     try {
65147       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65148     } catch (std::out_of_range& e) {
65149       {
65150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65151       };
65152     } catch (std::exception& e) {
65153       {
65154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65155       };
65156     } catch (Dali::DaliException e) {
65157       {
65158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65159       };
65160     } catch (...) {
65161       {
65162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65163       };
65164     }
65165   }
65166
65167   jresult = (void *)result;
65168   return jresult;
65169 }
65170
65171
65172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65173   void * jresult ;
65174   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65175   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65176
65177   arg1 = (Dali::Toolkit::Button *)jarg1;
65178   {
65179     try {
65180       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65181     } catch (std::out_of_range& e) {
65182       {
65183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65184       };
65185     } catch (std::exception& e) {
65186       {
65187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65188       };
65189     } catch (Dali::DaliException e) {
65190       {
65191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65192       };
65193     } catch (...) {
65194       {
65195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65196       };
65197     }
65198   }
65199
65200   jresult = (void *)result;
65201   return jresult;
65202 }
65203
65204
65205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65206   void * jresult ;
65207   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65208   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65209
65210   arg1 = (Dali::Toolkit::Button *)jarg1;
65211   {
65212     try {
65213       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65214     } catch (std::out_of_range& e) {
65215       {
65216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65217       };
65218     } catch (std::exception& e) {
65219       {
65220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65221       };
65222     } catch (Dali::DaliException e) {
65223       {
65224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65225       };
65226     } catch (...) {
65227       {
65228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65229       };
65230     }
65231   }
65232
65233   jresult = (void *)result;
65234   return jresult;
65235 }
65236
65237
65238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65239   void * jresult ;
65240   Dali::Toolkit::CheckBoxButton *result = 0 ;
65241
65242   {
65243     try {
65244       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65245     } catch (std::out_of_range& e) {
65246       {
65247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65248       };
65249     } catch (std::exception& e) {
65250       {
65251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65252       };
65253     } catch (Dali::DaliException e) {
65254       {
65255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65256       };
65257     } catch (...) {
65258       {
65259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65260       };
65261     }
65262   }
65263
65264   jresult = (void *)result;
65265   return jresult;
65266 }
65267
65268
65269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65270   void * jresult ;
65271   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65272   Dali::Toolkit::CheckBoxButton *result = 0 ;
65273
65274   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65275   if (!arg1) {
65276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65277     return 0;
65278   }
65279   {
65280     try {
65281       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65282     } catch (std::out_of_range& e) {
65283       {
65284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65285       };
65286     } catch (std::exception& e) {
65287       {
65288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65289       };
65290     } catch (Dali::DaliException e) {
65291       {
65292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65293       };
65294     } catch (...) {
65295       {
65296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65297       };
65298     }
65299   }
65300
65301   jresult = (void *)result;
65302   return jresult;
65303 }
65304
65305
65306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65307   void * jresult ;
65308   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65309   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65310   Dali::Toolkit::CheckBoxButton *result = 0 ;
65311
65312   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65313   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65314   if (!arg2) {
65315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65316     return 0;
65317   }
65318   {
65319     try {
65320       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
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_CheckBoxButton(void * jarg1) {
65346   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65347
65348   arg1 = (Dali::Toolkit::CheckBoxButton *)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_CheckBoxButton_New() {
65375   void * jresult ;
65376   Dali::Toolkit::CheckBoxButton result;
65377
65378   {
65379     try {
65380       result = Dali::Toolkit::CheckBoxButton::New();
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 = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65401   return jresult;
65402 }
65403
65404
65405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65406   void * jresult ;
65407   Dali::BaseHandle arg1 ;
65408   Dali::BaseHandle *argp1 ;
65409   Dali::Toolkit::CheckBoxButton result;
65410
65411   argp1 = (Dali::BaseHandle *)jarg1;
65412   if (!argp1) {
65413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65414     return 0;
65415   }
65416   arg1 = *argp1;
65417   {
65418     try {
65419       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65420     } catch (std::out_of_range& e) {
65421       {
65422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65423       };
65424     } catch (std::exception& e) {
65425       {
65426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65427       };
65428     } catch (Dali::DaliException e) {
65429       {
65430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65431       };
65432     } catch (...) {
65433       {
65434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65435       };
65436     }
65437   }
65438
65439   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65440   return jresult;
65441 }
65442
65443
65444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65445   int jresult ;
65446   int result;
65447
65448   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65449   jresult = (int)result;
65450   return jresult;
65451 }
65452
65453
65454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65455   int jresult ;
65456   int result;
65457
65458   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65459   jresult = (int)result;
65460   return jresult;
65461 }
65462
65463
65464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65465   void * jresult ;
65466   Dali::Toolkit::PushButton::Property *result = 0 ;
65467
65468   {
65469     try {
65470       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65471     } catch (std::out_of_range& e) {
65472       {
65473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65474       };
65475     } catch (std::exception& e) {
65476       {
65477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65478       };
65479     } catch (Dali::DaliException e) {
65480       {
65481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65482       };
65483     } catch (...) {
65484       {
65485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65486       };
65487     }
65488   }
65489
65490   jresult = (void *)result;
65491   return jresult;
65492 }
65493
65494
65495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65496   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65497
65498   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65499   {
65500     try {
65501       delete arg1;
65502     } catch (std::out_of_range& e) {
65503       {
65504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65505       };
65506     } catch (std::exception& e) {
65507       {
65508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65509       };
65510     } catch (Dali::DaliException e) {
65511       {
65512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65513       };
65514     } catch (...) {
65515       {
65516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65517       };
65518     }
65519   }
65520
65521 }
65522
65523
65524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65525   void * jresult ;
65526   Dali::Toolkit::PushButton *result = 0 ;
65527
65528   {
65529     try {
65530       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65531     } catch (std::out_of_range& e) {
65532       {
65533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65534       };
65535     } catch (std::exception& e) {
65536       {
65537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65538       };
65539     } catch (Dali::DaliException e) {
65540       {
65541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65542       };
65543     } catch (...) {
65544       {
65545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65546       };
65547     }
65548   }
65549
65550   jresult = (void *)result;
65551   return jresult;
65552 }
65553
65554
65555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65556   void * jresult ;
65557   Dali::Toolkit::PushButton *arg1 = 0 ;
65558   Dali::Toolkit::PushButton *result = 0 ;
65559
65560   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65561   if (!arg1) {
65562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65563     return 0;
65564   }
65565   {
65566     try {
65567       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65568     } catch (std::out_of_range& e) {
65569       {
65570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65571       };
65572     } catch (std::exception& e) {
65573       {
65574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65575       };
65576     } catch (Dali::DaliException e) {
65577       {
65578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65579       };
65580     } catch (...) {
65581       {
65582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65583       };
65584     }
65585   }
65586
65587   jresult = (void *)result;
65588   return jresult;
65589 }
65590
65591
65592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65593   void * jresult ;
65594   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65595   Dali::Toolkit::PushButton *arg2 = 0 ;
65596   Dali::Toolkit::PushButton *result = 0 ;
65597
65598   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65599   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65600   if (!arg2) {
65601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65602     return 0;
65603   }
65604   {
65605     try {
65606       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65607     } catch (std::out_of_range& e) {
65608       {
65609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65610       };
65611     } catch (std::exception& e) {
65612       {
65613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65614       };
65615     } catch (Dali::DaliException e) {
65616       {
65617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65618       };
65619     } catch (...) {
65620       {
65621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65622       };
65623     }
65624   }
65625
65626   jresult = (void *)result;
65627   return jresult;
65628 }
65629
65630
65631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65632   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65633
65634   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65635   {
65636     try {
65637       delete arg1;
65638     } catch (std::out_of_range& e) {
65639       {
65640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65641       };
65642     } catch (std::exception& e) {
65643       {
65644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65645       };
65646     } catch (Dali::DaliException e) {
65647       {
65648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65649       };
65650     } catch (...) {
65651       {
65652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65653       };
65654     }
65655   }
65656
65657 }
65658
65659
65660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65661   void * jresult ;
65662   Dali::Toolkit::PushButton result;
65663
65664   {
65665     try {
65666       result = Dali::Toolkit::PushButton::New();
65667     } catch (std::out_of_range& e) {
65668       {
65669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65670       };
65671     } catch (std::exception& e) {
65672       {
65673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65674       };
65675     } catch (Dali::DaliException e) {
65676       {
65677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65678       };
65679     } catch (...) {
65680       {
65681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65682       };
65683     }
65684   }
65685
65686   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65687   return jresult;
65688 }
65689
65690
65691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65692   void * jresult ;
65693   Dali::BaseHandle arg1 ;
65694   Dali::BaseHandle *argp1 ;
65695   Dali::Toolkit::PushButton result;
65696
65697   argp1 = (Dali::BaseHandle *)jarg1;
65698   if (!argp1) {
65699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65700     return 0;
65701   }
65702   arg1 = *argp1;
65703   {
65704     try {
65705       result = Dali::Toolkit::PushButton::DownCast(arg1);
65706     } catch (std::out_of_range& e) {
65707       {
65708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65709       };
65710     } catch (std::exception& e) {
65711       {
65712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65713       };
65714     } catch (Dali::DaliException e) {
65715       {
65716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65717       };
65718     } catch (...) {
65719       {
65720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65721       };
65722     }
65723   }
65724
65725   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65726   return jresult;
65727 }
65728
65729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65730   void * jresult ;
65731   Dali::Toolkit::RadioButton *result = 0 ;
65732
65733   {
65734     try {
65735       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65736     } catch (std::out_of_range& e) {
65737       {
65738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65739       };
65740     } catch (std::exception& e) {
65741       {
65742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65743       };
65744     } catch (Dali::DaliException e) {
65745       {
65746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65747       };
65748     } catch (...) {
65749       {
65750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65751       };
65752     }
65753   }
65754
65755   jresult = (void *)result;
65756   return jresult;
65757 }
65758
65759
65760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65761   void * jresult ;
65762   Dali::Toolkit::RadioButton *arg1 = 0 ;
65763   Dali::Toolkit::RadioButton *result = 0 ;
65764
65765   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65766   if (!arg1) {
65767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65768     return 0;
65769   }
65770   {
65771     try {
65772       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65773     } catch (std::out_of_range& e) {
65774       {
65775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65776       };
65777     } catch (std::exception& e) {
65778       {
65779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65780       };
65781     } catch (Dali::DaliException e) {
65782       {
65783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65784       };
65785     } catch (...) {
65786       {
65787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65788       };
65789     }
65790   }
65791
65792   jresult = (void *)result;
65793   return jresult;
65794 }
65795
65796
65797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65798   void * jresult ;
65799   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65800   Dali::Toolkit::RadioButton *arg2 = 0 ;
65801   Dali::Toolkit::RadioButton *result = 0 ;
65802
65803   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65804   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65805   if (!arg2) {
65806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65807     return 0;
65808   }
65809   {
65810     try {
65811       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65812     } catch (std::out_of_range& e) {
65813       {
65814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65815       };
65816     } catch (std::exception& e) {
65817       {
65818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65819       };
65820     } catch (Dali::DaliException e) {
65821       {
65822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65823       };
65824     } catch (...) {
65825       {
65826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65827       };
65828     }
65829   }
65830
65831   jresult = (void *)result;
65832   return jresult;
65833 }
65834
65835
65836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65837   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65838
65839   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65840   {
65841     try {
65842       delete arg1;
65843     } catch (std::out_of_range& e) {
65844       {
65845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65846       };
65847     } catch (std::exception& e) {
65848       {
65849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65850       };
65851     } catch (Dali::DaliException e) {
65852       {
65853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65854       };
65855     } catch (...) {
65856       {
65857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65858       };
65859     }
65860   }
65861
65862 }
65863
65864
65865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65866   void * jresult ;
65867   Dali::Toolkit::RadioButton result;
65868
65869   {
65870     try {
65871       result = Dali::Toolkit::RadioButton::New();
65872     } catch (std::out_of_range& e) {
65873       {
65874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65875       };
65876     } catch (std::exception& e) {
65877       {
65878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65879       };
65880     } catch (Dali::DaliException e) {
65881       {
65882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65883       };
65884     } catch (...) {
65885       {
65886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65887       };
65888     }
65889   }
65890
65891   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65892   return jresult;
65893 }
65894
65895
65896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65897   void * jresult ;
65898   std::string *arg1 = 0 ;
65899   Dali::Toolkit::RadioButton result;
65900
65901   if (!jarg1) {
65902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65903     return 0;
65904   }
65905   std::string arg1_str(jarg1);
65906   arg1 = &arg1_str;
65907   {
65908     try {
65909       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65910     } catch (std::out_of_range& e) {
65911       {
65912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65913       };
65914     } catch (std::exception& e) {
65915       {
65916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65917       };
65918     } catch (Dali::DaliException e) {
65919       {
65920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65921       };
65922     } catch (...) {
65923       {
65924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65925       };
65926     }
65927   }
65928
65929   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65930
65931   //argout typemap for const std::string&
65932
65933   return jresult;
65934 }
65935
65936
65937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65938   void * jresult ;
65939   Dali::BaseHandle arg1 ;
65940   Dali::BaseHandle *argp1 ;
65941   Dali::Toolkit::RadioButton result;
65942
65943   argp1 = (Dali::BaseHandle *)jarg1;
65944   if (!argp1) {
65945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65946     return 0;
65947   }
65948   arg1 = *argp1;
65949   {
65950     try {
65951       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65952     } catch (std::out_of_range& e) {
65953       {
65954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65955       };
65956     } catch (std::exception& e) {
65957       {
65958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65959       };
65960     } catch (Dali::DaliException e) {
65961       {
65962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65963       };
65964     } catch (...) {
65965       {
65966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65967       };
65968     }
65969   }
65970
65971   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65972   return jresult;
65973 }
65974
65975
65976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65977   int jresult ;
65978   int result;
65979
65980   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65981   jresult = (int)result;
65982   return jresult;
65983 }
65984
65985
65986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65987   int jresult ;
65988   int result;
65989
65990   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65991   jresult = (int)result;
65992   return jresult;
65993 }
65994
65995
65996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65997   int jresult ;
65998   int result;
65999
66000   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66001   jresult = (int)result;
66002   return jresult;
66003 }
66004
66005
66006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66007   int jresult ;
66008   int result;
66009
66010   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66011   jresult = (int)result;
66012   return jresult;
66013 }
66014
66015
66016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66017   int jresult ;
66018   int result;
66019
66020   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66021   jresult = (int)result;
66022   return jresult;
66023 }
66024
66025
66026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66027   int jresult ;
66028   int result;
66029
66030   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66031   jresult = (int)result;
66032   return jresult;
66033 }
66034
66035
66036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66037   void * jresult ;
66038   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66039
66040   {
66041     try {
66042       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
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_delete_FlexContainer_Property(void * jarg1) {
66068   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66069
66070   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66071   {
66072     try {
66073       delete arg1;
66074     } catch (std::out_of_range& e) {
66075       {
66076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66077       };
66078     } catch (std::exception& e) {
66079       {
66080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66081       };
66082     } catch (Dali::DaliException e) {
66083       {
66084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66085       };
66086     } catch (...) {
66087       {
66088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66089       };
66090     }
66091   }
66092
66093 }
66094
66095
66096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66097   int jresult ;
66098   int result;
66099
66100   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66101   jresult = (int)result;
66102   return jresult;
66103 }
66104
66105
66106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66107   int jresult ;
66108   int result;
66109
66110   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66111   jresult = (int)result;
66112   return jresult;
66113 }
66114
66115
66116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66117   int jresult ;
66118   int result;
66119
66120   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66121   jresult = (int)result;
66122   return jresult;
66123 }
66124
66125
66126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66127   void * jresult ;
66128   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66129
66130   {
66131     try {
66132       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66133     } catch (std::out_of_range& e) {
66134       {
66135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66136       };
66137     } catch (std::exception& e) {
66138       {
66139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66140       };
66141     } catch (Dali::DaliException e) {
66142       {
66143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66144       };
66145     } catch (...) {
66146       {
66147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66148       };
66149     }
66150   }
66151
66152   jresult = (void *)result;
66153   return jresult;
66154 }
66155
66156
66157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66158   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66159
66160   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66161   {
66162     try {
66163       delete arg1;
66164     } catch (std::out_of_range& e) {
66165       {
66166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66167       };
66168     } catch (std::exception& e) {
66169       {
66170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66171       };
66172     } catch (Dali::DaliException e) {
66173       {
66174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66175       };
66176     } catch (...) {
66177       {
66178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66179       };
66180     }
66181   }
66182
66183 }
66184
66185
66186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66187   void * jresult ;
66188   Dali::Toolkit::FlexContainer *result = 0 ;
66189
66190   {
66191     try {
66192       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66193     } catch (std::out_of_range& e) {
66194       {
66195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66196       };
66197     } catch (std::exception& e) {
66198       {
66199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66200       };
66201     } catch (Dali::DaliException e) {
66202       {
66203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66204       };
66205     } catch (...) {
66206       {
66207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66208       };
66209     }
66210   }
66211
66212   jresult = (void *)result;
66213   return jresult;
66214 }
66215
66216
66217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66218   void * jresult ;
66219   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66220   Dali::Toolkit::FlexContainer *result = 0 ;
66221
66222   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66223   if (!arg1) {
66224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66225     return 0;
66226   }
66227   {
66228     try {
66229       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66230     } catch (std::out_of_range& e) {
66231       {
66232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66233       };
66234     } catch (std::exception& e) {
66235       {
66236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66237       };
66238     } catch (Dali::DaliException e) {
66239       {
66240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66241       };
66242     } catch (...) {
66243       {
66244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66245       };
66246     }
66247   }
66248
66249   jresult = (void *)result;
66250   return jresult;
66251 }
66252
66253
66254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66255   void * jresult ;
66256   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66257   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66258   Dali::Toolkit::FlexContainer *result = 0 ;
66259
66260   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66261   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66262   if (!arg2) {
66263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66264     return 0;
66265   }
66266   {
66267     try {
66268       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66269     } catch (std::out_of_range& e) {
66270       {
66271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66272       };
66273     } catch (std::exception& e) {
66274       {
66275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66276       };
66277     } catch (Dali::DaliException e) {
66278       {
66279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66280       };
66281     } catch (...) {
66282       {
66283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66284       };
66285     }
66286   }
66287
66288   jresult = (void *)result;
66289   return jresult;
66290 }
66291
66292
66293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66294   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66295
66296   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66297   {
66298     try {
66299       delete arg1;
66300     } catch (std::out_of_range& e) {
66301       {
66302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66303       };
66304     } catch (std::exception& e) {
66305       {
66306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66307       };
66308     } catch (Dali::DaliException e) {
66309       {
66310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66311       };
66312     } catch (...) {
66313       {
66314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66315       };
66316     }
66317   }
66318
66319 }
66320
66321
66322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66323   void * jresult ;
66324   Dali::Toolkit::FlexContainer result;
66325
66326   {
66327     try {
66328       result = Dali::Toolkit::FlexContainer::New();
66329     } catch (std::out_of_range& e) {
66330       {
66331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66332       };
66333     } catch (std::exception& e) {
66334       {
66335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66336       };
66337     } catch (Dali::DaliException e) {
66338       {
66339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66340       };
66341     } catch (...) {
66342       {
66343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66344       };
66345     }
66346   }
66347
66348   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66349   return jresult;
66350 }
66351
66352
66353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66354   void * jresult ;
66355   Dali::BaseHandle arg1 ;
66356   Dali::BaseHandle *argp1 ;
66357   Dali::Toolkit::FlexContainer result;
66358
66359   argp1 = (Dali::BaseHandle *)jarg1;
66360   if (!argp1) {
66361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66362     return 0;
66363   }
66364   arg1 = *argp1;
66365   {
66366     try {
66367       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66368     } catch (std::out_of_range& e) {
66369       {
66370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66371       };
66372     } catch (std::exception& e) {
66373       {
66374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66375       };
66376     } catch (Dali::DaliException e) {
66377       {
66378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66379       };
66380     } catch (...) {
66381       {
66382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66383       };
66384     }
66385   }
66386
66387   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66388   return jresult;
66389 }
66390
66391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66392   int jresult ;
66393   int result;
66394
66395   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66396   jresult = (int)result;
66397   return jresult;
66398 }
66399
66400
66401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66402   int jresult ;
66403   int result;
66404
66405   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66406   jresult = (int)result;
66407   return jresult;
66408 }
66409
66410
66411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66412   int jresult ;
66413   int result;
66414
66415   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66416   jresult = (int)result;
66417   return jresult;
66418 }
66419
66420
66421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66422   void * jresult ;
66423   Dali::Toolkit::ImageView::Property *result = 0 ;
66424
66425   {
66426     try {
66427       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66428     } catch (std::out_of_range& e) {
66429       {
66430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66431       };
66432     } catch (std::exception& e) {
66433       {
66434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66435       };
66436     } catch (Dali::DaliException e) {
66437       {
66438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66439       };
66440     } catch (...) {
66441       {
66442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66443       };
66444     }
66445   }
66446
66447   jresult = (void *)result;
66448   return jresult;
66449 }
66450
66451
66452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66453   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66454
66455   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66456   {
66457     try {
66458       delete arg1;
66459     } catch (std::out_of_range& e) {
66460       {
66461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66462       };
66463     } catch (std::exception& e) {
66464       {
66465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66466       };
66467     } catch (Dali::DaliException e) {
66468       {
66469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66470       };
66471     } catch (...) {
66472       {
66473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66474       };
66475     }
66476   }
66477
66478 }
66479
66480
66481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66482   void * jresult ;
66483   Dali::Toolkit::ImageView *result = 0 ;
66484
66485   {
66486     try {
66487       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66488     } catch (std::out_of_range& e) {
66489       {
66490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66491       };
66492     } catch (std::exception& e) {
66493       {
66494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66495       };
66496     } catch (Dali::DaliException e) {
66497       {
66498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66499       };
66500     } catch (...) {
66501       {
66502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66503       };
66504     }
66505   }
66506
66507   jresult = (void *)result;
66508   return jresult;
66509 }
66510
66511
66512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66513   void * jresult ;
66514   Dali::Toolkit::ImageView result;
66515
66516   {
66517     try {
66518       result = Dali::Toolkit::ImageView::New();
66519     } catch (std::out_of_range& e) {
66520       {
66521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66522       };
66523     } catch (std::exception& e) {
66524       {
66525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66526       };
66527     } catch (Dali::DaliException e) {
66528       {
66529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66530       };
66531     } catch (...) {
66532       {
66533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66534       };
66535     }
66536   }
66537
66538   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66539   return jresult;
66540 }
66541
66542
66543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66544   void * jresult ;
66545   std::string *arg1 = 0 ;
66546   Dali::Toolkit::ImageView result;
66547
66548   if (!jarg1) {
66549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66550     return 0;
66551   }
66552   std::string arg1_str(jarg1);
66553   arg1 = &arg1_str;
66554   {
66555     try {
66556       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66557     } catch (std::out_of_range& e) {
66558       {
66559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66560       };
66561     } catch (std::exception& e) {
66562       {
66563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66564       };
66565     } catch (Dali::DaliException e) {
66566       {
66567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66568       };
66569     } catch (...) {
66570       {
66571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66572       };
66573     }
66574   }
66575
66576   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66577
66578   //argout typemap for const std::string&
66579
66580   return jresult;
66581 }
66582
66583
66584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66585   void * jresult ;
66586   std::string *arg1 = 0 ;
66587   Dali::ImageDimensions arg2 ;
66588   Dali::ImageDimensions *argp2 ;
66589   Dali::Toolkit::ImageView result;
66590
66591   if (!jarg1) {
66592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66593     return 0;
66594   }
66595   std::string arg1_str(jarg1);
66596   arg1 = &arg1_str;
66597   argp2 = (Dali::ImageDimensions *)jarg2;
66598   if (!argp2) {
66599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66600     return 0;
66601   }
66602   arg2 = *argp2;
66603   {
66604     try {
66605       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66606     } catch (std::out_of_range& e) {
66607       {
66608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66609       };
66610     } catch (std::exception& e) {
66611       {
66612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66613       };
66614     } catch (Dali::DaliException e) {
66615       {
66616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66617       };
66618     } catch (...) {
66619       {
66620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66621       };
66622     }
66623   }
66624
66625   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66626
66627   //argout typemap for const std::string&
66628
66629   return jresult;
66630 }
66631
66632
66633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66634   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66635
66636   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66637   {
66638     try {
66639       delete arg1;
66640     } catch (std::out_of_range& e) {
66641       {
66642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66643       };
66644     } catch (std::exception& e) {
66645       {
66646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66647       };
66648     } catch (Dali::DaliException e) {
66649       {
66650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66651       };
66652     } catch (...) {
66653       {
66654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66655       };
66656     }
66657   }
66658
66659 }
66660
66661
66662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66663   void * jresult ;
66664   Dali::Toolkit::ImageView *arg1 = 0 ;
66665   Dali::Toolkit::ImageView *result = 0 ;
66666
66667   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66668   if (!arg1) {
66669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66670     return 0;
66671   }
66672   {
66673     try {
66674       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66675     } catch (std::out_of_range& e) {
66676       {
66677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66678       };
66679     } catch (std::exception& e) {
66680       {
66681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66682       };
66683     } catch (Dali::DaliException e) {
66684       {
66685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66686       };
66687     } catch (...) {
66688       {
66689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66690       };
66691     }
66692   }
66693
66694   jresult = (void *)result;
66695   return jresult;
66696 }
66697
66698
66699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66700   void * jresult ;
66701   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66702   Dali::Toolkit::ImageView *arg2 = 0 ;
66703   Dali::Toolkit::ImageView *result = 0 ;
66704
66705   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66706   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66707   if (!arg2) {
66708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66709     return 0;
66710   }
66711   {
66712     try {
66713       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66714     } catch (std::out_of_range& e) {
66715       {
66716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66717       };
66718     } catch (std::exception& e) {
66719       {
66720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66721       };
66722     } catch (Dali::DaliException e) {
66723       {
66724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66725       };
66726     } catch (...) {
66727       {
66728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66729       };
66730     }
66731   }
66732
66733   jresult = (void *)result;
66734   return jresult;
66735 }
66736
66737
66738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66739   void * jresult ;
66740   Dali::BaseHandle arg1 ;
66741   Dali::BaseHandle *argp1 ;
66742   Dali::Toolkit::ImageView result;
66743
66744   argp1 = (Dali::BaseHandle *)jarg1;
66745   if (!argp1) {
66746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66747     return 0;
66748   }
66749   arg1 = *argp1;
66750   {
66751     try {
66752       result = Dali::Toolkit::ImageView::DownCast(arg1);
66753     } catch (std::out_of_range& e) {
66754       {
66755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66756       };
66757     } catch (std::exception& e) {
66758       {
66759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66760       };
66761     } catch (Dali::DaliException e) {
66762       {
66763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66764       };
66765     } catch (...) {
66766       {
66767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66768       };
66769     }
66770   }
66771
66772   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66773   return jresult;
66774 }
66775
66776
66777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66778   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66779   std::string *arg2 = 0 ;
66780
66781   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66782   if (!jarg2) {
66783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66784     return ;
66785   }
66786   std::string arg2_str(jarg2);
66787   arg2 = &arg2_str;
66788   {
66789     try {
66790       (arg1)->SetImage((std::string const &)*arg2);
66791     } catch (std::out_of_range& e) {
66792       {
66793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66794       };
66795     } catch (std::exception& e) {
66796       {
66797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66798       };
66799     } catch (Dali::DaliException e) {
66800       {
66801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66802       };
66803     } catch (...) {
66804       {
66805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66806       };
66807     }
66808   }
66809
66810
66811   //argout typemap for const std::string&
66812
66813 }
66814
66815
66816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66817   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66818   std::string *arg2 = 0 ;
66819   Dali::ImageDimensions arg3 ;
66820   Dali::ImageDimensions *argp3 ;
66821
66822   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66823   if (!jarg2) {
66824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66825     return ;
66826   }
66827   std::string arg2_str(jarg2);
66828   arg2 = &arg2_str;
66829   argp3 = (Dali::ImageDimensions *)jarg3;
66830   if (!argp3) {
66831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66832     return ;
66833   }
66834   arg3 = *argp3;
66835   {
66836     try {
66837       (arg1)->SetImage((std::string const &)*arg2,arg3);
66838     } catch (std::out_of_range& e) {
66839       {
66840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66841       };
66842     } catch (std::exception& e) {
66843       {
66844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66845       };
66846     } catch (Dali::DaliException e) {
66847       {
66848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66849       };
66850     } catch (...) {
66851       {
66852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66853       };
66854     }
66855   }
66856
66857
66858   //argout typemap for const std::string&
66859
66860 }
66861
66862
66863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66864   int jresult ;
66865   int result;
66866
66867   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66868   jresult = (int)result;
66869   return jresult;
66870 }
66871
66872
66873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66874   int jresult ;
66875   int result;
66876
66877   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66878   jresult = (int)result;
66879   return jresult;
66880 }
66881
66882
66883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66884   int jresult ;
66885   int result;
66886
66887   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66888   jresult = (int)result;
66889   return jresult;
66890 }
66891
66892
66893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66894   int jresult ;
66895   int result;
66896
66897   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66898   jresult = (int)result;
66899   return jresult;
66900 }
66901
66902
66903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66904   int jresult ;
66905   int result;
66906
66907   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66908   jresult = (int)result;
66909   return jresult;
66910 }
66911
66912
66913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66914   int jresult ;
66915   int result;
66916
66917   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66918   jresult = (int)result;
66919   return jresult;
66920 }
66921
66922
66923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66924   int jresult ;
66925   int result;
66926
66927   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66928   jresult = (int)result;
66929   return jresult;
66930 }
66931
66932
66933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66934   int jresult ;
66935   int result;
66936
66937   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66938   jresult = (int)result;
66939   return jresult;
66940 }
66941
66942
66943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66944   void * jresult ;
66945   Dali::Toolkit::Model3dView::Property *result = 0 ;
66946
66947   {
66948     try {
66949       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66950     } catch (std::out_of_range& e) {
66951       {
66952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66953       };
66954     } catch (std::exception& e) {
66955       {
66956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66957       };
66958     } catch (Dali::DaliException e) {
66959       {
66960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66961       };
66962     } catch (...) {
66963       {
66964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66965       };
66966     }
66967   }
66968
66969   jresult = (void *)result;
66970   return jresult;
66971 }
66972
66973
66974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66975   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66976
66977   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66978   {
66979     try {
66980       delete arg1;
66981     } catch (std::out_of_range& e) {
66982       {
66983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66984       };
66985     } catch (std::exception& e) {
66986       {
66987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66988       };
66989     } catch (Dali::DaliException e) {
66990       {
66991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66992       };
66993     } catch (...) {
66994       {
66995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66996       };
66997     }
66998   }
66999
67000 }
67001
67002
67003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67004   void * jresult ;
67005   Dali::Toolkit::Model3dView result;
67006
67007   {
67008     try {
67009       result = Dali::Toolkit::Model3dView::New();
67010     } catch (std::out_of_range& e) {
67011       {
67012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67013       };
67014     } catch (std::exception& e) {
67015       {
67016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67017       };
67018     } catch (Dali::DaliException e) {
67019       {
67020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67021       };
67022     } catch (...) {
67023       {
67024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67025       };
67026     }
67027   }
67028
67029   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67030   return jresult;
67031 }
67032
67033
67034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67035   void * jresult ;
67036   std::string *arg1 = 0 ;
67037   std::string *arg2 = 0 ;
67038   std::string *arg3 = 0 ;
67039   Dali::Toolkit::Model3dView result;
67040
67041   if (!jarg1) {
67042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67043     return 0;
67044   }
67045   std::string arg1_str(jarg1);
67046   arg1 = &arg1_str;
67047   if (!jarg2) {
67048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67049     return 0;
67050   }
67051   std::string arg2_str(jarg2);
67052   arg2 = &arg2_str;
67053   if (!jarg3) {
67054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67055     return 0;
67056   }
67057   std::string arg3_str(jarg3);
67058   arg3 = &arg3_str;
67059   {
67060     try {
67061       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67062     } catch (std::out_of_range& e) {
67063       {
67064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67065       };
67066     } catch (std::exception& e) {
67067       {
67068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67069       };
67070     } catch (Dali::DaliException e) {
67071       {
67072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67073       };
67074     } catch (...) {
67075       {
67076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67077       };
67078     }
67079   }
67080
67081   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67082
67083   //argout typemap for const std::string&
67084
67085
67086   //argout typemap for const std::string&
67087
67088
67089   //argout typemap for const std::string&
67090
67091   return jresult;
67092 }
67093
67094
67095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67096   void * jresult ;
67097   Dali::Toolkit::Model3dView *result = 0 ;
67098
67099   {
67100     try {
67101       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67102     } catch (std::out_of_range& e) {
67103       {
67104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67105       };
67106     } catch (std::exception& e) {
67107       {
67108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67109       };
67110     } catch (Dali::DaliException e) {
67111       {
67112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67113       };
67114     } catch (...) {
67115       {
67116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67117       };
67118     }
67119   }
67120
67121   jresult = (void *)result;
67122   return jresult;
67123 }
67124
67125
67126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67127   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67128
67129   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67130   {
67131     try {
67132       delete arg1;
67133     } catch (std::out_of_range& e) {
67134       {
67135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67136       };
67137     } catch (std::exception& e) {
67138       {
67139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67140       };
67141     } catch (Dali::DaliException e) {
67142       {
67143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67144       };
67145     } catch (...) {
67146       {
67147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67148       };
67149     }
67150   }
67151
67152 }
67153
67154
67155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67156   void * jresult ;
67157   Dali::Toolkit::Model3dView *arg1 = 0 ;
67158   Dali::Toolkit::Model3dView *result = 0 ;
67159
67160   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67161   if (!arg1) {
67162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67163     return 0;
67164   }
67165   {
67166     try {
67167       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67168     } catch (std::out_of_range& e) {
67169       {
67170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67171       };
67172     } catch (std::exception& e) {
67173       {
67174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67175       };
67176     } catch (Dali::DaliException e) {
67177       {
67178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67179       };
67180     } catch (...) {
67181       {
67182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67183       };
67184     }
67185   }
67186
67187   jresult = (void *)result;
67188   return jresult;
67189 }
67190
67191
67192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67193   void * jresult ;
67194   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67195   Dali::Toolkit::Model3dView *arg2 = 0 ;
67196   Dali::Toolkit::Model3dView *result = 0 ;
67197
67198   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67199   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67200   if (!arg2) {
67201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67202     return 0;
67203   }
67204   {
67205     try {
67206       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67207     } catch (std::out_of_range& e) {
67208       {
67209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67210       };
67211     } catch (std::exception& e) {
67212       {
67213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67214       };
67215     } catch (Dali::DaliException e) {
67216       {
67217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67218       };
67219     } catch (...) {
67220       {
67221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67222       };
67223     }
67224   }
67225
67226   jresult = (void *)result;
67227   return jresult;
67228 }
67229
67230
67231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67232   void * jresult ;
67233   Dali::BaseHandle arg1 ;
67234   Dali::BaseHandle *argp1 ;
67235   Dali::Toolkit::Model3dView result;
67236
67237   argp1 = (Dali::BaseHandle *)jarg1;
67238   if (!argp1) {
67239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67240     return 0;
67241   }
67242   arg1 = *argp1;
67243   {
67244     try {
67245       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67246     } catch (std::out_of_range& e) {
67247       {
67248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67249       };
67250     } catch (std::exception& e) {
67251       {
67252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67253       };
67254     } catch (Dali::DaliException e) {
67255       {
67256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67257       };
67258     } catch (...) {
67259       {
67260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67261       };
67262     }
67263   }
67264
67265   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67266   return jresult;
67267 }
67268
67269
67270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67271   int jresult ;
67272   int result;
67273
67274   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67275   jresult = (int)result;
67276   return jresult;
67277 }
67278
67279
67280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67281   int jresult ;
67282   int result;
67283
67284   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67285   jresult = (int)result;
67286   return jresult;
67287 }
67288
67289
67290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67291   int jresult ;
67292   int result;
67293
67294   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67295   jresult = (int)result;
67296   return jresult;
67297 }
67298
67299
67300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67301   int jresult ;
67302   int result;
67303
67304   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67305   jresult = (int)result;
67306   return jresult;
67307 }
67308
67309
67310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67311   int jresult ;
67312   int result;
67313
67314   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67315   jresult = (int)result;
67316   return jresult;
67317 }
67318
67319
67320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67321   int jresult ;
67322   int result;
67323
67324   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67325   jresult = (int)result;
67326   return jresult;
67327 }
67328
67329
67330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67331   int jresult ;
67332   int result;
67333
67334   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67335   jresult = (int)result;
67336   return jresult;
67337 }
67338
67339
67340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67341   int jresult ;
67342   int result;
67343
67344   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67345   jresult = (int)result;
67346   return jresult;
67347 }
67348
67349
67350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67351   int jresult ;
67352   int result;
67353
67354   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67355   jresult = (int)result;
67356   return jresult;
67357 }
67358
67359
67360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67361   void * jresult ;
67362   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67363
67364   {
67365     try {
67366       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67367     } catch (std::out_of_range& e) {
67368       {
67369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67370       };
67371     } catch (std::exception& e) {
67372       {
67373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67374       };
67375     } catch (Dali::DaliException e) {
67376       {
67377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67378       };
67379     } catch (...) {
67380       {
67381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67382       };
67383     }
67384   }
67385
67386   jresult = (void *)result;
67387   return jresult;
67388 }
67389
67390
67391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67392   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67393
67394   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67395   {
67396     try {
67397       delete arg1;
67398     } catch (std::out_of_range& e) {
67399       {
67400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67401       };
67402     } catch (std::exception& e) {
67403       {
67404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67405       };
67406     } catch (Dali::DaliException e) {
67407       {
67408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67409       };
67410     } catch (...) {
67411       {
67412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67413       };
67414     }
67415   }
67416
67417 }
67418
67419
67420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67421   void * jresult ;
67422   Dali::Toolkit::ScrollBar *result = 0 ;
67423
67424   {
67425     try {
67426       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67427     } catch (std::out_of_range& e) {
67428       {
67429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67430       };
67431     } catch (std::exception& e) {
67432       {
67433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67434       };
67435     } catch (Dali::DaliException e) {
67436       {
67437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67438       };
67439     } catch (...) {
67440       {
67441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67442       };
67443     }
67444   }
67445
67446   jresult = (void *)result;
67447   return jresult;
67448 }
67449
67450
67451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67452   void * jresult ;
67453   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67454   Dali::Toolkit::ScrollBar *result = 0 ;
67455
67456   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67457   if (!arg1) {
67458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67459     return 0;
67460   }
67461   {
67462     try {
67463       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67464     } catch (std::out_of_range& e) {
67465       {
67466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67467       };
67468     } catch (std::exception& e) {
67469       {
67470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67471       };
67472     } catch (Dali::DaliException e) {
67473       {
67474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67475       };
67476     } catch (...) {
67477       {
67478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67479       };
67480     }
67481   }
67482
67483   jresult = (void *)result;
67484   return jresult;
67485 }
67486
67487
67488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67489   void * jresult ;
67490   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67491   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67492   Dali::Toolkit::ScrollBar *result = 0 ;
67493
67494   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67495   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67496   if (!arg2) {
67497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67498     return 0;
67499   }
67500   {
67501     try {
67502       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67503     } catch (std::out_of_range& e) {
67504       {
67505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67506       };
67507     } catch (std::exception& e) {
67508       {
67509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67510       };
67511     } catch (Dali::DaliException e) {
67512       {
67513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67514       };
67515     } catch (...) {
67516       {
67517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67518       };
67519     }
67520   }
67521
67522   jresult = (void *)result;
67523   return jresult;
67524 }
67525
67526
67527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67528   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67529
67530   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67531   {
67532     try {
67533       delete arg1;
67534     } catch (std::out_of_range& e) {
67535       {
67536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67537       };
67538     } catch (std::exception& e) {
67539       {
67540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67541       };
67542     } catch (Dali::DaliException e) {
67543       {
67544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67545       };
67546     } catch (...) {
67547       {
67548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67549       };
67550     }
67551   }
67552
67553 }
67554
67555
67556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67557   void * jresult ;
67558   Dali::Toolkit::ScrollBar::Direction arg1 ;
67559   Dali::Toolkit::ScrollBar result;
67560
67561   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67562   {
67563     try {
67564       result = Dali::Toolkit::ScrollBar::New(arg1);
67565     } catch (std::out_of_range& e) {
67566       {
67567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67568       };
67569     } catch (std::exception& e) {
67570       {
67571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67572       };
67573     } catch (Dali::DaliException e) {
67574       {
67575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67576       };
67577     } catch (...) {
67578       {
67579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67580       };
67581     }
67582   }
67583
67584   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67585   return jresult;
67586 }
67587
67588
67589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67590   void * jresult ;
67591   Dali::Toolkit::ScrollBar result;
67592
67593   {
67594     try {
67595       result = Dali::Toolkit::ScrollBar::New();
67596     } catch (std::out_of_range& e) {
67597       {
67598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67599       };
67600     } catch (std::exception& e) {
67601       {
67602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67603       };
67604     } catch (Dali::DaliException e) {
67605       {
67606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67607       };
67608     } catch (...) {
67609       {
67610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67611       };
67612     }
67613   }
67614
67615   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67616   return jresult;
67617 }
67618
67619
67620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67621   void * jresult ;
67622   Dali::BaseHandle arg1 ;
67623   Dali::BaseHandle *argp1 ;
67624   Dali::Toolkit::ScrollBar result;
67625
67626   argp1 = (Dali::BaseHandle *)jarg1;
67627   if (!argp1) {
67628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67629     return 0;
67630   }
67631   arg1 = *argp1;
67632   {
67633     try {
67634       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67635     } catch (std::out_of_range& e) {
67636       {
67637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67638       };
67639     } catch (std::exception& e) {
67640       {
67641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67642       };
67643     } catch (Dali::DaliException e) {
67644       {
67645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67646       };
67647     } catch (...) {
67648       {
67649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67650       };
67651     }
67652   }
67653
67654   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67655   return jresult;
67656 }
67657
67658
67659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67660   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67661   Dali::Handle arg2 ;
67662   Dali::Property::Index arg3 ;
67663   Dali::Property::Index arg4 ;
67664   Dali::Property::Index arg5 ;
67665   Dali::Property::Index arg6 ;
67666   Dali::Handle *argp2 ;
67667
67668   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67669   argp2 = (Dali::Handle *)jarg2;
67670   if (!argp2) {
67671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67672     return ;
67673   }
67674   arg2 = *argp2;
67675   arg3 = (Dali::Property::Index)jarg3;
67676   arg4 = (Dali::Property::Index)jarg4;
67677   arg5 = (Dali::Property::Index)jarg5;
67678   arg6 = (Dali::Property::Index)jarg6;
67679   {
67680     try {
67681       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67682     } catch (std::out_of_range& e) {
67683       {
67684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67685       };
67686     } catch (std::exception& e) {
67687       {
67688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67689       };
67690     } catch (Dali::DaliException e) {
67691       {
67692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67693       };
67694     } catch (...) {
67695       {
67696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67697       };
67698     }
67699   }
67700
67701 }
67702
67703
67704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67705   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67706   Dali::Actor arg2 ;
67707   Dali::Actor *argp2 ;
67708
67709   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67710   argp2 = (Dali::Actor *)jarg2;
67711   if (!argp2) {
67712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67713     return ;
67714   }
67715   arg2 = *argp2;
67716   {
67717     try {
67718       (arg1)->SetScrollIndicator(arg2);
67719     } catch (std::out_of_range& e) {
67720       {
67721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67722       };
67723     } catch (std::exception& e) {
67724       {
67725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67726       };
67727     } catch (Dali::DaliException e) {
67728       {
67729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67730       };
67731     } catch (...) {
67732       {
67733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67734       };
67735     }
67736   }
67737
67738 }
67739
67740
67741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67742   void * jresult ;
67743   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67744   Dali::Actor result;
67745
67746   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67747   {
67748     try {
67749       result = (arg1)->GetScrollIndicator();
67750     } catch (std::out_of_range& e) {
67751       {
67752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67753       };
67754     } catch (std::exception& e) {
67755       {
67756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67757       };
67758     } catch (Dali::DaliException e) {
67759       {
67760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67761       };
67762     } catch (...) {
67763       {
67764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67765       };
67766     }
67767   }
67768
67769   jresult = new Dali::Actor((const Dali::Actor &)result);
67770   return jresult;
67771 }
67772
67773
67774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67775   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67776   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67777
67778   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67779   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67780   if (!arg2) {
67781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67782     return ;
67783   }
67784   {
67785     try {
67786       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67787     } catch (std::out_of_range& e) {
67788       {
67789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67790       };
67791     } catch (std::exception& e) {
67792       {
67793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67794       };
67795     } catch (Dali::DaliException e) {
67796       {
67797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67798       };
67799     } catch (...) {
67800       {
67801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67802       };
67803     }
67804   }
67805
67806 }
67807
67808
67809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67810   void * jresult ;
67811   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67812
67813   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67814   {
67815     try {
67816       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()));
67817     } catch (std::out_of_range& e) {
67818       {
67819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67820       };
67821     } catch (std::exception& e) {
67822       {
67823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67824       };
67825     } catch (...) {
67826       {
67827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67828       };
67829     }
67830   }
67831   return jresult;
67832 }
67833
67834
67835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67836   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67837   Dali::Toolkit::ScrollBar::Direction arg2 ;
67838
67839   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67840   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67841   {
67842     try {
67843       (arg1)->SetScrollDirection(arg2);
67844     } catch (std::out_of_range& e) {
67845       {
67846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67847       };
67848     } catch (std::exception& e) {
67849       {
67850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67851       };
67852     } catch (Dali::DaliException e) {
67853       {
67854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67855       };
67856     } catch (...) {
67857       {
67858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67859       };
67860     }
67861   }
67862
67863 }
67864
67865
67866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67867   int jresult ;
67868   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67869   Dali::Toolkit::ScrollBar::Direction result;
67870
67871   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67872   {
67873     try {
67874       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67875     } catch (std::out_of_range& e) {
67876       {
67877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67878       };
67879     } catch (std::exception& e) {
67880       {
67881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67882       };
67883     } catch (Dali::DaliException e) {
67884       {
67885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67886       };
67887     } catch (...) {
67888       {
67889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67890       };
67891     }
67892   }
67893
67894   jresult = (int)result;
67895   return jresult;
67896 }
67897
67898
67899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67900   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67901   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67902
67903   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67904   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67905   {
67906     try {
67907       (arg1)->SetIndicatorHeightPolicy(arg2);
67908     } catch (std::out_of_range& e) {
67909       {
67910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67911       };
67912     } catch (std::exception& e) {
67913       {
67914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67915       };
67916     } catch (Dali::DaliException e) {
67917       {
67918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67919       };
67920     } catch (...) {
67921       {
67922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67923       };
67924     }
67925   }
67926
67927 }
67928
67929
67930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67931   int jresult ;
67932   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67933   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67934
67935   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67936   {
67937     try {
67938       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67939     } catch (std::out_of_range& e) {
67940       {
67941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67942       };
67943     } catch (std::exception& e) {
67944       {
67945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67946       };
67947     } catch (Dali::DaliException e) {
67948       {
67949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67950       };
67951     } catch (...) {
67952       {
67953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67954       };
67955     }
67956   }
67957
67958   jresult = (int)result;
67959   return jresult;
67960 }
67961
67962
67963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67964   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67965   float arg2 ;
67966
67967   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67968   arg2 = (float)jarg2;
67969   {
67970     try {
67971       (arg1)->SetIndicatorFixedHeight(arg2);
67972     } catch (std::out_of_range& e) {
67973       {
67974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67975       };
67976     } catch (std::exception& e) {
67977       {
67978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67979       };
67980     } catch (Dali::DaliException e) {
67981       {
67982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67983       };
67984     } catch (...) {
67985       {
67986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67987       };
67988     }
67989   }
67990
67991 }
67992
67993
67994 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67995   float jresult ;
67996   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67997   float result;
67998
67999   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68000   {
68001     try {
68002       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68003     } catch (std::out_of_range& e) {
68004       {
68005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68006       };
68007     } catch (std::exception& e) {
68008       {
68009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68010       };
68011     } catch (Dali::DaliException e) {
68012       {
68013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68014       };
68015     } catch (...) {
68016       {
68017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68018       };
68019     }
68020   }
68021
68022   jresult = result;
68023   return jresult;
68024 }
68025
68026
68027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68028   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68029   float arg2 ;
68030
68031   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68032   arg2 = (float)jarg2;
68033   {
68034     try {
68035       (arg1)->SetIndicatorShowDuration(arg2);
68036     } catch (std::out_of_range& e) {
68037       {
68038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68039       };
68040     } catch (std::exception& e) {
68041       {
68042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68043       };
68044     } catch (Dali::DaliException e) {
68045       {
68046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68047       };
68048     } catch (...) {
68049       {
68050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68051       };
68052     }
68053   }
68054
68055 }
68056
68057
68058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68059   float jresult ;
68060   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68061   float result;
68062
68063   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68064   {
68065     try {
68066       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68067     } catch (std::out_of_range& e) {
68068       {
68069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68070       };
68071     } catch (std::exception& e) {
68072       {
68073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68074       };
68075     } catch (Dali::DaliException e) {
68076       {
68077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68078       };
68079     } catch (...) {
68080       {
68081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68082       };
68083     }
68084   }
68085
68086   jresult = result;
68087   return jresult;
68088 }
68089
68090
68091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68092   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68093   float arg2 ;
68094
68095   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68096   arg2 = (float)jarg2;
68097   {
68098     try {
68099       (arg1)->SetIndicatorHideDuration(arg2);
68100     } catch (std::out_of_range& e) {
68101       {
68102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68103       };
68104     } catch (std::exception& e) {
68105       {
68106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68107       };
68108     } catch (Dali::DaliException e) {
68109       {
68110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68111       };
68112     } catch (...) {
68113       {
68114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68115       };
68116     }
68117   }
68118
68119 }
68120
68121
68122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68123   float jresult ;
68124   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68125   float result;
68126
68127   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68128   {
68129     try {
68130       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68131     } catch (std::out_of_range& e) {
68132       {
68133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68134       };
68135     } catch (std::exception& e) {
68136       {
68137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68138       };
68139     } catch (Dali::DaliException e) {
68140       {
68141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68142       };
68143     } catch (...) {
68144       {
68145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68146       };
68147     }
68148   }
68149
68150   jresult = result;
68151   return jresult;
68152 }
68153
68154
68155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68156   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68157
68158   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68159   {
68160     try {
68161       (arg1)->ShowIndicator();
68162     } catch (std::out_of_range& e) {
68163       {
68164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68165       };
68166     } catch (std::exception& e) {
68167       {
68168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68169       };
68170     } catch (Dali::DaliException e) {
68171       {
68172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68173       };
68174     } catch (...) {
68175       {
68176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68177       };
68178     }
68179   }
68180
68181 }
68182
68183
68184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68185   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68186
68187   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68188   {
68189     try {
68190       (arg1)->HideIndicator();
68191     } catch (std::out_of_range& e) {
68192       {
68193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68194       };
68195     } catch (std::exception& e) {
68196       {
68197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68198       };
68199     } catch (Dali::DaliException e) {
68200       {
68201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68202       };
68203     } catch (...) {
68204       {
68205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68206       };
68207     }
68208   }
68209
68210 }
68211
68212
68213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68214   void * jresult ;
68215   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68216   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68217
68218   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68219   {
68220     try {
68221       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68222     } catch (std::out_of_range& e) {
68223       {
68224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68225       };
68226     } catch (std::exception& e) {
68227       {
68228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68229       };
68230     } catch (Dali::DaliException e) {
68231       {
68232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68233       };
68234     } catch (...) {
68235       {
68236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68237       };
68238     }
68239   }
68240
68241   jresult = (void *)result;
68242   return jresult;
68243 }
68244
68245
68246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68247   void * jresult ;
68248   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68249   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68250
68251   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68252   {
68253     try {
68254       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68255     } catch (std::out_of_range& e) {
68256       {
68257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68258       };
68259     } catch (std::exception& e) {
68260       {
68261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68262       };
68263     } catch (Dali::DaliException e) {
68264       {
68265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68266       };
68267     } catch (...) {
68268       {
68269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68270       };
68271     }
68272   }
68273
68274   jresult = (void *)result;
68275   return jresult;
68276 }
68277
68278
68279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68280   int jresult ;
68281   int result;
68282
68283   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68284   jresult = (int)result;
68285   return jresult;
68286 }
68287
68288
68289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68290   int jresult ;
68291   int result;
68292
68293   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68294   jresult = (int)result;
68295   return jresult;
68296 }
68297
68298
68299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68300   int jresult ;
68301   int result;
68302
68303   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68304   jresult = (int)result;
68305   return jresult;
68306 }
68307
68308
68309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68310   int jresult ;
68311   int result;
68312
68313   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68314   jresult = (int)result;
68315   return jresult;
68316 }
68317
68318
68319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68320   int jresult ;
68321   int result;
68322
68323   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68324   jresult = (int)result;
68325   return jresult;
68326 }
68327
68328
68329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68330   int jresult ;
68331   int result;
68332
68333   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68334   jresult = (int)result;
68335   return jresult;
68336 }
68337
68338
68339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68340   int jresult ;
68341   int result;
68342
68343   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68344   jresult = (int)result;
68345   return jresult;
68346 }
68347
68348
68349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68350   int jresult ;
68351   int result;
68352
68353   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68354   jresult = (int)result;
68355   return jresult;
68356 }
68357
68358
68359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68360   int jresult ;
68361   int result;
68362
68363   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68364   jresult = (int)result;
68365   return jresult;
68366 }
68367
68368
68369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68370   int jresult ;
68371   int result;
68372
68373   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68374   jresult = (int)result;
68375   return jresult;
68376 }
68377
68378
68379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68380   int jresult ;
68381   int result;
68382
68383   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68384   jresult = (int)result;
68385   return jresult;
68386 }
68387
68388
68389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68390   int jresult ;
68391   int result;
68392
68393   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68394   jresult = (int)result;
68395   return jresult;
68396 }
68397
68398
68399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68400   int jresult ;
68401   int result;
68402
68403   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68404   jresult = (int)result;
68405   return jresult;
68406 }
68407
68408
68409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68410   int jresult ;
68411   int result;
68412
68413   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68414   jresult = (int)result;
68415   return jresult;
68416 }
68417
68418
68419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68420   void * jresult ;
68421   Dali::Toolkit::Scrollable::Property *result = 0 ;
68422
68423   {
68424     try {
68425       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68426     } catch (std::out_of_range& e) {
68427       {
68428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68429       };
68430     } catch (std::exception& e) {
68431       {
68432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68433       };
68434     } catch (Dali::DaliException e) {
68435       {
68436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68437       };
68438     } catch (...) {
68439       {
68440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68441       };
68442     }
68443   }
68444
68445   jresult = (void *)result;
68446   return jresult;
68447 }
68448
68449
68450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68451   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68452
68453   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68454   {
68455     try {
68456       delete arg1;
68457     } catch (std::out_of_range& e) {
68458       {
68459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68460       };
68461     } catch (std::exception& e) {
68462       {
68463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68464       };
68465     } catch (Dali::DaliException e) {
68466       {
68467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68468       };
68469     } catch (...) {
68470       {
68471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68472       };
68473     }
68474   }
68475
68476 }
68477
68478
68479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68480   void * jresult ;
68481   Dali::Toolkit::Scrollable *result = 0 ;
68482
68483   {
68484     try {
68485       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68486     } catch (std::out_of_range& e) {
68487       {
68488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68489       };
68490     } catch (std::exception& e) {
68491       {
68492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68493       };
68494     } catch (Dali::DaliException e) {
68495       {
68496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68497       };
68498     } catch (...) {
68499       {
68500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68501       };
68502     }
68503   }
68504
68505   jresult = (void *)result;
68506   return jresult;
68507 }
68508
68509
68510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68511   void * jresult ;
68512   Dali::Toolkit::Scrollable *arg1 = 0 ;
68513   Dali::Toolkit::Scrollable *result = 0 ;
68514
68515   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68516   if (!arg1) {
68517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68518     return 0;
68519   }
68520   {
68521     try {
68522       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68523     } catch (std::out_of_range& e) {
68524       {
68525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68526       };
68527     } catch (std::exception& e) {
68528       {
68529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68530       };
68531     } catch (Dali::DaliException e) {
68532       {
68533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68534       };
68535     } catch (...) {
68536       {
68537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68538       };
68539     }
68540   }
68541
68542   jresult = (void *)result;
68543   return jresult;
68544 }
68545
68546
68547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68548   void * jresult ;
68549   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68550   Dali::Toolkit::Scrollable *arg2 = 0 ;
68551   Dali::Toolkit::Scrollable *result = 0 ;
68552
68553   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68554   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68555   if (!arg2) {
68556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68557     return 0;
68558   }
68559   {
68560     try {
68561       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68562     } catch (std::out_of_range& e) {
68563       {
68564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68565       };
68566     } catch (std::exception& e) {
68567       {
68568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68569       };
68570     } catch (Dali::DaliException e) {
68571       {
68572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68573       };
68574     } catch (...) {
68575       {
68576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68577       };
68578     }
68579   }
68580
68581   jresult = (void *)result;
68582   return jresult;
68583 }
68584
68585
68586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68587   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68588
68589   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68590   {
68591     try {
68592       delete arg1;
68593     } catch (std::out_of_range& e) {
68594       {
68595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68596       };
68597     } catch (std::exception& e) {
68598       {
68599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68600       };
68601     } catch (Dali::DaliException e) {
68602       {
68603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68604       };
68605     } catch (...) {
68606       {
68607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68608       };
68609     }
68610   }
68611
68612 }
68613
68614
68615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68616   void * jresult ;
68617   Dali::BaseHandle arg1 ;
68618   Dali::BaseHandle *argp1 ;
68619   Dali::Toolkit::Scrollable result;
68620
68621   argp1 = (Dali::BaseHandle *)jarg1;
68622   if (!argp1) {
68623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68624     return 0;
68625   }
68626   arg1 = *argp1;
68627   {
68628     try {
68629       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68630     } catch (std::out_of_range& e) {
68631       {
68632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68633       };
68634     } catch (std::exception& e) {
68635       {
68636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68637       };
68638     } catch (Dali::DaliException e) {
68639       {
68640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68641       };
68642     } catch (...) {
68643       {
68644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68645       };
68646     }
68647   }
68648
68649   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68650   return jresult;
68651 }
68652
68653
68654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68655   unsigned int jresult ;
68656   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68657   bool result;
68658
68659   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68660   {
68661     try {
68662       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68663     } catch (std::out_of_range& e) {
68664       {
68665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68666       };
68667     } catch (std::exception& e) {
68668       {
68669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68670       };
68671     } catch (Dali::DaliException e) {
68672       {
68673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68674       };
68675     } catch (...) {
68676       {
68677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68678       };
68679     }
68680   }
68681
68682   jresult = result;
68683   return jresult;
68684 }
68685
68686
68687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68688   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68689   bool arg2 ;
68690
68691   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68692   arg2 = jarg2 ? true : false;
68693   {
68694     try {
68695       (arg1)->SetOvershootEnabled(arg2);
68696     } catch (std::out_of_range& e) {
68697       {
68698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68699       };
68700     } catch (std::exception& e) {
68701       {
68702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68703       };
68704     } catch (Dali::DaliException e) {
68705       {
68706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68707       };
68708     } catch (...) {
68709       {
68710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68711       };
68712     }
68713   }
68714
68715 }
68716
68717
68718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68719   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68720   Dali::Vector4 *arg2 = 0 ;
68721
68722   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68723   arg2 = (Dali::Vector4 *)jarg2;
68724   if (!arg2) {
68725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68726     return ;
68727   }
68728   {
68729     try {
68730       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68731     } catch (std::out_of_range& e) {
68732       {
68733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68734       };
68735     } catch (std::exception& e) {
68736       {
68737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68738       };
68739     } catch (Dali::DaliException e) {
68740       {
68741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68742       };
68743     } catch (...) {
68744       {
68745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68746       };
68747     }
68748   }
68749
68750 }
68751
68752
68753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68754   void * jresult ;
68755   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68756   Dali::Vector4 result;
68757
68758   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68759   {
68760     try {
68761       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68762     } catch (std::out_of_range& e) {
68763       {
68764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68765       };
68766     } catch (std::exception& e) {
68767       {
68768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68769       };
68770     } catch (Dali::DaliException e) {
68771       {
68772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68773       };
68774     } catch (...) {
68775       {
68776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68777       };
68778     }
68779   }
68780
68781   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68782   return jresult;
68783 }
68784
68785
68786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68787   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68788   float arg2 ;
68789
68790   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68791   arg2 = (float)jarg2;
68792   {
68793     try {
68794       (arg1)->SetOvershootAnimationSpeed(arg2);
68795     } catch (std::out_of_range& e) {
68796       {
68797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68798       };
68799     } catch (std::exception& e) {
68800       {
68801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68802       };
68803     } catch (Dali::DaliException e) {
68804       {
68805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68806       };
68807     } catch (...) {
68808       {
68809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68810       };
68811     }
68812   }
68813
68814 }
68815
68816
68817 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68818   float jresult ;
68819   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68820   float result;
68821
68822   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68823   {
68824     try {
68825       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68826     } catch (std::out_of_range& e) {
68827       {
68828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68829       };
68830     } catch (std::exception& e) {
68831       {
68832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68833       };
68834     } catch (Dali::DaliException e) {
68835       {
68836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68837       };
68838     } catch (...) {
68839       {
68840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68841       };
68842     }
68843   }
68844
68845   jresult = result;
68846   return jresult;
68847 }
68848
68849
68850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68851   void * jresult ;
68852   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68853   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68854
68855   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68856   {
68857     try {
68858       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68859     } catch (std::out_of_range& e) {
68860       {
68861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68862       };
68863     } catch (std::exception& e) {
68864       {
68865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68866       };
68867     } catch (Dali::DaliException e) {
68868       {
68869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68870       };
68871     } catch (...) {
68872       {
68873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68874       };
68875     }
68876   }
68877
68878   jresult = (void *)result;
68879   return jresult;
68880 }
68881
68882
68883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68884   void * jresult ;
68885   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68886   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68887
68888   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68889   {
68890     try {
68891       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68892     } catch (std::out_of_range& e) {
68893       {
68894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68895       };
68896     } catch (std::exception& e) {
68897       {
68898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68899       };
68900     } catch (Dali::DaliException e) {
68901       {
68902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68903       };
68904     } catch (...) {
68905       {
68906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68907       };
68908     }
68909   }
68910
68911   jresult = (void *)result;
68912   return jresult;
68913 }
68914
68915
68916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68917   void * jresult ;
68918   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68919   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68920
68921   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68922   {
68923     try {
68924       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68925     } catch (std::out_of_range& e) {
68926       {
68927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68928       };
68929     } catch (std::exception& e) {
68930       {
68931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68932       };
68933     } catch (Dali::DaliException e) {
68934       {
68935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68936       };
68937     } catch (...) {
68938       {
68939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68940       };
68941     }
68942   }
68943
68944   jresult = (void *)result;
68945   return jresult;
68946 }
68947
68948
68949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68950   unsigned int jresult ;
68951   Dali::Toolkit::ControlOrientation::Type arg1 ;
68952   bool result;
68953
68954   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68955   {
68956     try {
68957       result = (bool)Dali::Toolkit::IsVertical(arg1);
68958     } catch (std::out_of_range& e) {
68959       {
68960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68961       };
68962     } catch (std::exception& e) {
68963       {
68964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68965       };
68966     } catch (Dali::DaliException e) {
68967       {
68968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68969       };
68970     } catch (...) {
68971       {
68972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68973       };
68974     }
68975   }
68976
68977   jresult = result;
68978   return jresult;
68979 }
68980
68981
68982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68983   unsigned int jresult ;
68984   Dali::Toolkit::ControlOrientation::Type arg1 ;
68985   bool result;
68986
68987   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68988   {
68989     try {
68990       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68991     } catch (std::out_of_range& e) {
68992       {
68993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68994       };
68995     } catch (std::exception& e) {
68996       {
68997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68998       };
68999     } catch (Dali::DaliException e) {
69000       {
69001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69002       };
69003     } catch (...) {
69004       {
69005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69006       };
69007     }
69008   }
69009
69010   jresult = result;
69011   return jresult;
69012 }
69013
69014
69015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69016   void * jresult ;
69017   unsigned int arg1 ;
69018   unsigned int arg2 ;
69019   Dali::Toolkit::ItemRange *result = 0 ;
69020
69021   arg1 = (unsigned int)jarg1;
69022   arg2 = (unsigned int)jarg2;
69023   {
69024     try {
69025       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,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 = (void *)result;
69046   return jresult;
69047 }
69048
69049
69050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69051   void * jresult ;
69052   Dali::Toolkit::ItemRange *arg1 = 0 ;
69053   Dali::Toolkit::ItemRange *result = 0 ;
69054
69055   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69056   if (!arg1) {
69057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69058     return 0;
69059   }
69060   {
69061     try {
69062       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69063     } catch (std::out_of_range& e) {
69064       {
69065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69066       };
69067     } catch (std::exception& e) {
69068       {
69069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69070       };
69071     } catch (Dali::DaliException e) {
69072       {
69073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69074       };
69075     } catch (...) {
69076       {
69077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69078       };
69079     }
69080   }
69081
69082   jresult = (void *)result;
69083   return jresult;
69084 }
69085
69086
69087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69088   void * jresult ;
69089   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69090   Dali::Toolkit::ItemRange *arg2 = 0 ;
69091   Dali::Toolkit::ItemRange *result = 0 ;
69092
69093   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69094   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69095   if (!arg2) {
69096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69097     return 0;
69098   }
69099   {
69100     try {
69101       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69102     } catch (std::out_of_range& e) {
69103       {
69104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69105       };
69106     } catch (std::exception& e) {
69107       {
69108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69109       };
69110     } catch (Dali::DaliException e) {
69111       {
69112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69113       };
69114     } catch (...) {
69115       {
69116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69117       };
69118     }
69119   }
69120
69121   jresult = (void *)result;
69122   return jresult;
69123 }
69124
69125
69126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69127   unsigned int jresult ;
69128   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69129   unsigned int arg2 ;
69130   bool result;
69131
69132   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69133   arg2 = (unsigned int)jarg2;
69134   {
69135     try {
69136       result = (bool)(arg1)->Within(arg2);
69137     } catch (std::out_of_range& e) {
69138       {
69139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69140       };
69141     } catch (std::exception& e) {
69142       {
69143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69144       };
69145     } catch (Dali::DaliException e) {
69146       {
69147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69148       };
69149     } catch (...) {
69150       {
69151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69152       };
69153     }
69154   }
69155
69156   jresult = result;
69157   return jresult;
69158 }
69159
69160
69161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69162   void * jresult ;
69163   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69164   Dali::Toolkit::ItemRange *arg2 = 0 ;
69165   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69166
69167   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69168   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69169   if (!arg2) {
69170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69171     return 0;
69172   }
69173   {
69174     try {
69175       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69176     } catch (std::out_of_range& e) {
69177       {
69178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69179       };
69180     } catch (std::exception& e) {
69181       {
69182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69183       };
69184     } catch (Dali::DaliException e) {
69185       {
69186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69187       };
69188     } catch (...) {
69189       {
69190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69191       };
69192     }
69193   }
69194
69195   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69196   return jresult;
69197 }
69198
69199
69200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69201   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69202   unsigned int arg2 ;
69203
69204   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69205   arg2 = (unsigned int)jarg2;
69206   if (arg1) (arg1)->begin = arg2;
69207 }
69208
69209
69210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69211   unsigned int jresult ;
69212   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69213   unsigned int result;
69214
69215   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69216   result = (unsigned int) ((arg1)->begin);
69217   jresult = result;
69218   return jresult;
69219 }
69220
69221
69222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69223   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69224   unsigned int arg2 ;
69225
69226   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69227   arg2 = (unsigned int)jarg2;
69228   if (arg1) (arg1)->end = arg2;
69229 }
69230
69231
69232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69233   unsigned int jresult ;
69234   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69235   unsigned int result;
69236
69237   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69238   result = (unsigned int) ((arg1)->end);
69239   jresult = result;
69240   return jresult;
69241 }
69242
69243
69244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69245   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69246
69247   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69248   {
69249     try {
69250       delete arg1;
69251     } catch (std::out_of_range& e) {
69252       {
69253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69254       };
69255     } catch (std::exception& e) {
69256       {
69257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69258       };
69259     } catch (Dali::DaliException e) {
69260       {
69261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69262       };
69263     } catch (...) {
69264       {
69265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69266       };
69267     }
69268   }
69269
69270 }
69271
69272
69273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69274   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69275
69276   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69277   {
69278     try {
69279       delete arg1;
69280     } catch (std::out_of_range& e) {
69281       {
69282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69283       };
69284     } catch (std::exception& e) {
69285       {
69286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69287       };
69288     } catch (Dali::DaliException e) {
69289       {
69290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69291       };
69292     } catch (...) {
69293       {
69294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69295       };
69296     }
69297   }
69298
69299 }
69300
69301
69302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69303   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69304   Dali::Toolkit::ControlOrientation::Type arg2 ;
69305
69306   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69307   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69308   {
69309     try {
69310       (arg1)->SetOrientation(arg2);
69311     } catch (std::out_of_range& e) {
69312       {
69313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69314       };
69315     } catch (std::exception& e) {
69316       {
69317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69318       };
69319     } catch (Dali::DaliException e) {
69320       {
69321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69322       };
69323     } catch (...) {
69324       {
69325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69326       };
69327     }
69328   }
69329
69330 }
69331
69332
69333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69334   int jresult ;
69335   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69336   Dali::Toolkit::ControlOrientation::Type result;
69337
69338   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69339   {
69340     try {
69341       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69342     } catch (std::out_of_range& e) {
69343       {
69344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69345       };
69346     } catch (std::exception& e) {
69347       {
69348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69349       };
69350     } catch (Dali::DaliException e) {
69351       {
69352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69353       };
69354     } catch (...) {
69355       {
69356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69357       };
69358     }
69359   }
69360
69361   jresult = (int)result;
69362   return jresult;
69363 }
69364
69365
69366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69367   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69368   Dali::Property::Map *arg2 = 0 ;
69369
69370   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69371   arg2 = (Dali::Property::Map *)jarg2;
69372   if (!arg2) {
69373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69374     return ;
69375   }
69376   {
69377     try {
69378       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69379     } catch (std::out_of_range& e) {
69380       {
69381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69382       };
69383     } catch (std::exception& e) {
69384       {
69385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69386       };
69387     } catch (Dali::DaliException e) {
69388       {
69389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69390       };
69391     } catch (...) {
69392       {
69393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69394       };
69395     }
69396   }
69397
69398 }
69399
69400
69401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69402   void * jresult ;
69403   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69404   Dali::Property::Map result;
69405
69406   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69407   {
69408     try {
69409       result = (arg1)->GetLayoutProperties();
69410     } catch (std::out_of_range& e) {
69411       {
69412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69413       };
69414     } catch (std::exception& e) {
69415       {
69416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69417       };
69418     } catch (Dali::DaliException e) {
69419       {
69420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69421       };
69422     } catch (...) {
69423       {
69424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69425       };
69426     }
69427   }
69428
69429   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69430   return jresult;
69431 }
69432
69433
69434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69435   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69436   unsigned int arg2 ;
69437   Dali::Vector3 *arg3 = 0 ;
69438   Dali::Vector3 *arg4 = 0 ;
69439
69440   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69441   arg2 = (unsigned int)jarg2;
69442   arg3 = (Dali::Vector3 *)jarg3;
69443   if (!arg3) {
69444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69445     return ;
69446   }
69447   arg4 = (Dali::Vector3 *)jarg4;
69448   if (!arg4) {
69449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69450     return ;
69451   }
69452   {
69453     try {
69454       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69455     } catch (std::out_of_range& e) {
69456       {
69457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69458       };
69459     } catch (std::exception& e) {
69460       {
69461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69462       };
69463     } catch (Dali::DaliException e) {
69464       {
69465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69466       };
69467     } catch (...) {
69468       {
69469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69470       };
69471     }
69472   }
69473
69474 }
69475
69476
69477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69478   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69479   Dali::Vector3 *arg2 = 0 ;
69480
69481   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69482   arg2 = (Dali::Vector3 *)jarg2;
69483   if (!arg2) {
69484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69485     return ;
69486   }
69487   {
69488     try {
69489       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69490     } catch (std::out_of_range& e) {
69491       {
69492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69493       };
69494     } catch (std::exception& e) {
69495       {
69496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69497       };
69498     } catch (Dali::DaliException e) {
69499       {
69500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69501       };
69502     } catch (...) {
69503       {
69504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69505       };
69506     }
69507   }
69508
69509 }
69510
69511
69512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69513   float jresult ;
69514   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69515   unsigned int arg2 ;
69516   Dali::Vector3 arg3 ;
69517   Dali::Vector3 *argp3 ;
69518   float result;
69519
69520   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69521   arg2 = (unsigned int)jarg2;
69522   argp3 = (Dali::Vector3 *)jarg3;
69523   if (!argp3) {
69524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69525     return 0;
69526   }
69527   arg3 = *argp3;
69528   {
69529     try {
69530       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69531     } catch (std::out_of_range& e) {
69532       {
69533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69534       };
69535     } catch (std::exception& e) {
69536       {
69537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69538       };
69539     } catch (Dali::DaliException e) {
69540       {
69541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69542       };
69543     } catch (...) {
69544       {
69545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69546       };
69547     }
69548   }
69549
69550   jresult = result;
69551   return jresult;
69552 }
69553
69554
69555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69556   float jresult ;
69557   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69558   float arg2 ;
69559   float result;
69560
69561   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69562   arg2 = (float)jarg2;
69563   {
69564     try {
69565       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69566     } catch (std::out_of_range& e) {
69567       {
69568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69569       };
69570     } catch (std::exception& e) {
69571       {
69572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69573       };
69574     } catch (Dali::DaliException e) {
69575       {
69576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69577       };
69578     } catch (...) {
69579       {
69580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69581       };
69582     }
69583   }
69584
69585   jresult = result;
69586   return jresult;
69587 }
69588
69589
69590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69591   float jresult ;
69592   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69593   unsigned int arg2 ;
69594   float result;
69595
69596   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69597   arg2 = (unsigned int)jarg2;
69598   {
69599     try {
69600       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69601     } catch (std::out_of_range& e) {
69602       {
69603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69604       };
69605     } catch (std::exception& e) {
69606       {
69607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69608       };
69609     } catch (Dali::DaliException e) {
69610       {
69611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69612       };
69613     } catch (...) {
69614       {
69615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69616       };
69617     }
69618   }
69619
69620   jresult = result;
69621   return jresult;
69622 }
69623
69624
69625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69626   void * jresult ;
69627   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69628   float arg2 ;
69629   Dali::Vector3 arg3 ;
69630   Dali::Vector3 *argp3 ;
69631   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69632
69633   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69634   arg2 = (float)jarg2;
69635   argp3 = (Dali::Vector3 *)jarg3;
69636   if (!argp3) {
69637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69638     return 0;
69639   }
69640   arg3 = *argp3;
69641   {
69642     try {
69643       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69644     } catch (std::out_of_range& e) {
69645       {
69646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69647       };
69648     } catch (std::exception& e) {
69649       {
69650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69651       };
69652     } catch (Dali::DaliException e) {
69653       {
69654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69655       };
69656     } catch (...) {
69657       {
69658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69659       };
69660     }
69661   }
69662
69663   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69664   return jresult;
69665 }
69666
69667
69668 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69669   float jresult ;
69670   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69671   int arg2 ;
69672   float arg3 ;
69673   Dali::Vector3 *arg4 = 0 ;
69674   float result;
69675
69676   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69677   arg2 = (int)jarg2;
69678   arg3 = (float)jarg3;
69679   arg4 = (Dali::Vector3 *)jarg4;
69680   if (!arg4) {
69681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69682     return 0;
69683   }
69684   {
69685     try {
69686       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
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 unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69712   unsigned int jresult ;
69713   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69714   Dali::Vector3 arg2 ;
69715   Dali::Vector3 *argp2 ;
69716   unsigned int result;
69717
69718   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69719   argp2 = (Dali::Vector3 *)jarg2;
69720   if (!argp2) {
69721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69722     return 0;
69723   }
69724   arg2 = *argp2;
69725   {
69726     try {
69727       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69728     } catch (std::out_of_range& e) {
69729       {
69730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69731       };
69732     } catch (std::exception& e) {
69733       {
69734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69735       };
69736     } catch (Dali::DaliException e) {
69737       {
69738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69739       };
69740     } catch (...) {
69741       {
69742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69743       };
69744     }
69745   }
69746
69747   jresult = result;
69748   return jresult;
69749 }
69750
69751
69752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69753   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69754   unsigned int arg2 ;
69755   Dali::Vector3 *arg3 = 0 ;
69756   Dali::Vector3 *arg4 = 0 ;
69757
69758   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69759   arg2 = (unsigned int)jarg2;
69760   arg3 = (Dali::Vector3 *)jarg3;
69761   if (!arg3) {
69762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69763     return ;
69764   }
69765   arg4 = (Dali::Vector3 *)jarg4;
69766   if (!arg4) {
69767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69768     return ;
69769   }
69770   {
69771     try {
69772       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69773     } catch (std::out_of_range& e) {
69774       {
69775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69776       };
69777     } catch (std::exception& e) {
69778       {
69779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69780       };
69781     } catch (Dali::DaliException e) {
69782       {
69783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69784       };
69785     } catch (...) {
69786       {
69787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69788       };
69789     }
69790   }
69791
69792 }
69793
69794
69795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69796   void * jresult ;
69797   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69798   Dali::Degree result;
69799
69800   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69801   {
69802     try {
69803       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69804     } catch (std::out_of_range& e) {
69805       {
69806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69807       };
69808     } catch (std::exception& e) {
69809       {
69810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69811       };
69812     } catch (Dali::DaliException e) {
69813       {
69814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69815       };
69816     } catch (...) {
69817       {
69818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69819       };
69820     }
69821   }
69822
69823   jresult = new Dali::Degree((const Dali::Degree &)result);
69824   return jresult;
69825 }
69826
69827
69828 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69829   float jresult ;
69830   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69831   float result;
69832
69833   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69834   {
69835     try {
69836       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69837     } catch (std::out_of_range& e) {
69838       {
69839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69840       };
69841     } catch (std::exception& e) {
69842       {
69843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69844       };
69845     } catch (Dali::DaliException e) {
69846       {
69847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69848       };
69849     } catch (...) {
69850       {
69851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69852       };
69853     }
69854   }
69855
69856   jresult = result;
69857   return jresult;
69858 }
69859
69860
69861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69862   float jresult ;
69863   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69864   float result;
69865
69866   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69867   {
69868     try {
69869       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69870     } catch (std::out_of_range& e) {
69871       {
69872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69873       };
69874     } catch (std::exception& e) {
69875       {
69876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69877       };
69878     } catch (Dali::DaliException e) {
69879       {
69880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69881       };
69882     } catch (...) {
69883       {
69884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69885       };
69886     }
69887   }
69888
69889   jresult = result;
69890   return jresult;
69891 }
69892
69893
69894 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69895   float jresult ;
69896   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69897   float result;
69898
69899   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69900   {
69901     try {
69902       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69903     } catch (std::out_of_range& e) {
69904       {
69905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69906       };
69907     } catch (std::exception& e) {
69908       {
69909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69910       };
69911     } catch (Dali::DaliException e) {
69912       {
69913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69914       };
69915     } catch (...) {
69916       {
69917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69918       };
69919     }
69920   }
69921
69922   jresult = result;
69923   return jresult;
69924 }
69925
69926
69927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69928   int jresult ;
69929   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69930   int arg2 ;
69931   int arg3 ;
69932   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69933   bool arg5 ;
69934   int result;
69935
69936   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69937   arg2 = (int)jarg2;
69938   arg3 = (int)jarg3;
69939   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69940   arg5 = jarg5 ? true : false;
69941   {
69942     try {
69943       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69944     } catch (std::out_of_range& e) {
69945       {
69946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69947       };
69948     } catch (std::exception& e) {
69949       {
69950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69951       };
69952     } catch (Dali::DaliException e) {
69953       {
69954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69955       };
69956     } catch (...) {
69957       {
69958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69959       };
69960     }
69961   }
69962
69963   jresult = result;
69964   return jresult;
69965 }
69966
69967
69968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69969   float jresult ;
69970   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69971   float result;
69972
69973   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69974   {
69975     try {
69976       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69977     } catch (std::out_of_range& e) {
69978       {
69979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69980       };
69981     } catch (std::exception& e) {
69982       {
69983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69984       };
69985     } catch (Dali::DaliException e) {
69986       {
69987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69988       };
69989     } catch (...) {
69990       {
69991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69992       };
69993     }
69994   }
69995
69996   jresult = result;
69997   return jresult;
69998 }
69999
70000
70001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70002   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70003   Dali::Actor *arg2 = 0 ;
70004   int arg3 ;
70005   Dali::Vector3 *arg4 = 0 ;
70006   Dali::Actor *arg5 = 0 ;
70007
70008   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70009   arg2 = (Dali::Actor *)jarg2;
70010   if (!arg2) {
70011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70012     return ;
70013   }
70014   arg3 = (int)jarg3;
70015   arg4 = (Dali::Vector3 *)jarg4;
70016   if (!arg4) {
70017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70018     return ;
70019   }
70020   arg5 = (Dali::Actor *)jarg5;
70021   if (!arg5) {
70022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70023     return ;
70024   }
70025   {
70026     try {
70027       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70028     } catch (std::out_of_range& e) {
70029       {
70030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70031       };
70032     } catch (std::exception& e) {
70033       {
70034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70035       };
70036     } catch (Dali::DaliException e) {
70037       {
70038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70039       };
70040     } catch (...) {
70041       {
70042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70043       };
70044     }
70045   }
70046
70047 }
70048
70049
70050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70051   void * jresult ;
70052   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70053   int arg2 ;
70054   float arg3 ;
70055   Dali::Vector3 *arg4 = 0 ;
70056   Dali::Vector3 result;
70057
70058   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70059   arg2 = (int)jarg2;
70060   arg3 = (float)jarg3;
70061   arg4 = (Dali::Vector3 *)jarg4;
70062   if (!arg4) {
70063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70064     return 0;
70065   }
70066   {
70067     try {
70068       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70069     } catch (std::out_of_range& e) {
70070       {
70071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70072       };
70073     } catch (std::exception& e) {
70074       {
70075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70076       };
70077     } catch (Dali::DaliException e) {
70078       {
70079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70080       };
70081     } catch (...) {
70082       {
70083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70084       };
70085     }
70086   }
70087
70088   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70089   return jresult;
70090 }
70091
70092
70093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70094   void * jresult ;
70095   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70096   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70097
70098   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70099   {
70100     try {
70101       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70102     } catch (std::out_of_range& e) {
70103       {
70104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70105       };
70106     } catch (std::exception& e) {
70107       {
70108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70109       };
70110     } catch (Dali::DaliException e) {
70111       {
70112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70113       };
70114     } catch (...) {
70115       {
70116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70117       };
70118     }
70119   }
70120
70121   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70122   return jresult;
70123 }
70124
70125
70126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70127   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70128
70129   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70130   {
70131     try {
70132       delete arg1;
70133     } catch (std::out_of_range& e) {
70134       {
70135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70136       };
70137     } catch (std::exception& e) {
70138       {
70139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70140       };
70141     } catch (Dali::DaliException e) {
70142       {
70143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70144       };
70145     } catch (...) {
70146       {
70147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70148       };
70149     }
70150   }
70151
70152 }
70153
70154
70155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70156   unsigned int jresult ;
70157   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70158   unsigned int result;
70159
70160   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70161   {
70162     try {
70163       result = (unsigned int)(arg1)->GetNumberOfItems();
70164     } catch (std::out_of_range& e) {
70165       {
70166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70167       };
70168     } catch (std::exception& e) {
70169       {
70170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70171       };
70172     } catch (Dali::DaliException e) {
70173       {
70174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70175       };
70176     } catch (...) {
70177       {
70178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70179       };
70180     }
70181   }
70182
70183   jresult = result;
70184   return jresult;
70185 }
70186
70187
70188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70189   void * jresult ;
70190   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70191   unsigned int arg2 ;
70192   Dali::Actor result;
70193
70194   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70195   arg2 = (unsigned int)jarg2;
70196   {
70197     try {
70198       result = (arg1)->NewItem(arg2);
70199     } catch (std::out_of_range& e) {
70200       {
70201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70202       };
70203     } catch (std::exception& e) {
70204       {
70205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70206       };
70207     } catch (Dali::DaliException e) {
70208       {
70209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70210       };
70211     } catch (...) {
70212       {
70213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70214       };
70215     }
70216   }
70217
70218   jresult = new Dali::Actor((const Dali::Actor &)result);
70219   return jresult;
70220 }
70221
70222
70223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70224   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70225   unsigned int arg2 ;
70226   Dali::Actor arg3 ;
70227   Dali::Actor *argp3 ;
70228
70229   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70230   arg2 = (unsigned int)jarg2;
70231   argp3 = (Dali::Actor *)jarg3;
70232   if (!argp3) {
70233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70234     return ;
70235   }
70236   arg3 = *argp3;
70237   {
70238     try {
70239       (arg1)->ItemReleased(arg2,arg3);
70240     } catch (std::out_of_range& e) {
70241       {
70242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70243       };
70244     } catch (std::exception& e) {
70245       {
70246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70247       };
70248     } catch (Dali::DaliException e) {
70249       {
70250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70251       };
70252     } catch (...) {
70253       {
70254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70255       };
70256     }
70257   }
70258
70259 }
70260
70261
70262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70263   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70264   unsigned int arg2 ;
70265   Dali::Actor arg3 ;
70266   Dali::Actor *argp3 ;
70267
70268   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70269   arg2 = (unsigned int)jarg2;
70270   argp3 = (Dali::Actor *)jarg3;
70271   if (!argp3) {
70272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70273     return ;
70274   }
70275   arg3 = *argp3;
70276   {
70277     try {
70278       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70279     } catch (std::out_of_range& e) {
70280       {
70281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70282       };
70283     } catch (std::exception& e) {
70284       {
70285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70286       };
70287     } catch (Dali::DaliException e) {
70288       {
70289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70290       };
70291     } catch (...) {
70292       {
70293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70294       };
70295     }
70296   }
70297
70298 }
70299
70300
70301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70302   void * jresult ;
70303   Dali::Toolkit::ItemFactory *result = 0 ;
70304
70305   {
70306     try {
70307       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
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_ItemFactory_director_connect(void *objarg, SwigDirector_ItemFactory::SWIG_Callback0_t callback0, SwigDirector_ItemFactory::SWIG_Callback1_t callback1, SwigDirector_ItemFactory::SWIG_Callback2_t callback2) {
70333   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70334   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70335   if (director) {
70336     director->swig_connect_director(callback0, callback1, callback2);
70337   }
70338 }
70339
70340
70341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70342   int jresult ;
70343   int result;
70344
70345   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70346   jresult = (int)result;
70347   return jresult;
70348 }
70349
70350
70351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70352   int jresult ;
70353   int result;
70354
70355   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70356   jresult = (int)result;
70357   return jresult;
70358 }
70359
70360
70361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70362   int jresult ;
70363   int result;
70364
70365   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70366   jresult = (int)result;
70367   return jresult;
70368 }
70369
70370
70371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70372   int jresult ;
70373   int result;
70374
70375   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70376   jresult = (int)result;
70377   return jresult;
70378 }
70379
70380
70381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70382   int jresult ;
70383   int result;
70384
70385   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70386   jresult = (int)result;
70387   return jresult;
70388 }
70389
70390
70391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70392   int jresult ;
70393   int result;
70394
70395   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70396   jresult = (int)result;
70397   return jresult;
70398 }
70399
70400
70401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70402   int jresult ;
70403   int result;
70404
70405   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70406   jresult = (int)result;
70407   return jresult;
70408 }
70409
70410
70411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70412   int jresult ;
70413   int result;
70414
70415   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70416   jresult = (int)result;
70417   return jresult;
70418 }
70419
70420
70421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70422   int jresult ;
70423   int result;
70424
70425   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70426   jresult = (int)result;
70427   return jresult;
70428 }
70429
70430
70431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70432   int jresult ;
70433   int result;
70434
70435   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70436   jresult = (int)result;
70437   return jresult;
70438 }
70439
70440
70441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70442   int jresult ;
70443   int result;
70444
70445   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70446   jresult = (int)result;
70447   return jresult;
70448 }
70449
70450
70451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70452   void * jresult ;
70453   Dali::Toolkit::ItemView::Property *result = 0 ;
70454
70455   {
70456     try {
70457       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70458     } catch (std::out_of_range& e) {
70459       {
70460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70461       };
70462     } catch (std::exception& e) {
70463       {
70464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70465       };
70466     } catch (Dali::DaliException e) {
70467       {
70468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70469       };
70470     } catch (...) {
70471       {
70472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70473       };
70474     }
70475   }
70476
70477   jresult = (void *)result;
70478   return jresult;
70479 }
70480
70481
70482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70483   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70484
70485   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70486   {
70487     try {
70488       delete arg1;
70489     } catch (std::out_of_range& e) {
70490       {
70491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70492       };
70493     } catch (std::exception& e) {
70494       {
70495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70496       };
70497     } catch (Dali::DaliException e) {
70498       {
70499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70500       };
70501     } catch (...) {
70502       {
70503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70504       };
70505     }
70506   }
70507
70508 }
70509
70510
70511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70512   void * jresult ;
70513   Dali::Toolkit::ItemView *result = 0 ;
70514
70515   {
70516     try {
70517       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70518     } catch (std::out_of_range& e) {
70519       {
70520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70521       };
70522     } catch (std::exception& e) {
70523       {
70524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70525       };
70526     } catch (Dali::DaliException e) {
70527       {
70528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70529       };
70530     } catch (...) {
70531       {
70532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70533       };
70534     }
70535   }
70536
70537   jresult = (void *)result;
70538   return jresult;
70539 }
70540
70541
70542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70543   void * jresult ;
70544   Dali::Toolkit::ItemView *arg1 = 0 ;
70545   Dali::Toolkit::ItemView *result = 0 ;
70546
70547   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70548   if (!arg1) {
70549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70550     return 0;
70551   }
70552   {
70553     try {
70554       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70555     } catch (std::out_of_range& e) {
70556       {
70557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70558       };
70559     } catch (std::exception& e) {
70560       {
70561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70562       };
70563     } catch (Dali::DaliException e) {
70564       {
70565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70566       };
70567     } catch (...) {
70568       {
70569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70570       };
70571     }
70572   }
70573
70574   jresult = (void *)result;
70575   return jresult;
70576 }
70577
70578
70579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70580   void * jresult ;
70581   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70582   Dali::Toolkit::ItemView *arg2 = 0 ;
70583   Dali::Toolkit::ItemView *result = 0 ;
70584
70585   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70586   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70587   if (!arg2) {
70588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70589     return 0;
70590   }
70591   {
70592     try {
70593       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70594     } catch (std::out_of_range& e) {
70595       {
70596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70597       };
70598     } catch (std::exception& e) {
70599       {
70600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70601       };
70602     } catch (Dali::DaliException e) {
70603       {
70604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70605       };
70606     } catch (...) {
70607       {
70608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70609       };
70610     }
70611   }
70612
70613   jresult = (void *)result;
70614   return jresult;
70615 }
70616
70617
70618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70619   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70620
70621   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70622   {
70623     try {
70624       delete arg1;
70625     } catch (std::out_of_range& e) {
70626       {
70627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70628       };
70629     } catch (std::exception& e) {
70630       {
70631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70632       };
70633     } catch (Dali::DaliException e) {
70634       {
70635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70636       };
70637     } catch (...) {
70638       {
70639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70640       };
70641     }
70642   }
70643
70644 }
70645
70646
70647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70648   void * jresult ;
70649   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70650   Dali::Toolkit::ItemView result;
70651
70652   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70653   if (!arg1) {
70654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70655     return 0;
70656   }
70657   {
70658     try {
70659       result = Dali::Toolkit::ItemView::New(*arg1);
70660     } catch (std::out_of_range& e) {
70661       {
70662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70663       };
70664     } catch (std::exception& e) {
70665       {
70666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70667       };
70668     } catch (Dali::DaliException e) {
70669       {
70670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70671       };
70672     } catch (...) {
70673       {
70674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70675       };
70676     }
70677   }
70678
70679   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70680   return jresult;
70681 }
70682
70683
70684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70685   void * jresult ;
70686   Dali::BaseHandle arg1 ;
70687   Dali::BaseHandle *argp1 ;
70688   Dali::Toolkit::ItemView result;
70689
70690   argp1 = (Dali::BaseHandle *)jarg1;
70691   if (!argp1) {
70692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70693     return 0;
70694   }
70695   arg1 = *argp1;
70696   {
70697     try {
70698       result = Dali::Toolkit::ItemView::DownCast(arg1);
70699     } catch (std::out_of_range& e) {
70700       {
70701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70702       };
70703     } catch (std::exception& e) {
70704       {
70705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70706       };
70707     } catch (Dali::DaliException e) {
70708       {
70709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70710       };
70711     } catch (...) {
70712       {
70713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70714       };
70715     }
70716   }
70717
70718   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70719   return jresult;
70720 }
70721
70722
70723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70724   unsigned int jresult ;
70725   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70726   unsigned int result;
70727
70728   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70729   {
70730     try {
70731       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70732     } catch (std::out_of_range& e) {
70733       {
70734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70735       };
70736     } catch (std::exception& e) {
70737       {
70738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70739       };
70740     } catch (Dali::DaliException e) {
70741       {
70742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70743       };
70744     } catch (...) {
70745       {
70746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70747       };
70748     }
70749   }
70750
70751   jresult = result;
70752   return jresult;
70753 }
70754
70755
70756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70757   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70758   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70759
70760   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70761   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70762   if (!arg2) {
70763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70764     return ;
70765   }
70766   {
70767     try {
70768       (arg1)->AddLayout(*arg2);
70769     } catch (std::out_of_range& e) {
70770       {
70771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70772       };
70773     } catch (std::exception& e) {
70774       {
70775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70776       };
70777     } catch (Dali::DaliException e) {
70778       {
70779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70780       };
70781     } catch (...) {
70782       {
70783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70784       };
70785     }
70786   }
70787
70788 }
70789
70790
70791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70792   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70793   unsigned int arg2 ;
70794
70795   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70796   arg2 = (unsigned int)jarg2;
70797   {
70798     try {
70799       (arg1)->RemoveLayout(arg2);
70800     } catch (std::out_of_range& e) {
70801       {
70802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70803       };
70804     } catch (std::exception& e) {
70805       {
70806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70807       };
70808     } catch (Dali::DaliException e) {
70809       {
70810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70811       };
70812     } catch (...) {
70813       {
70814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70815       };
70816     }
70817   }
70818
70819 }
70820
70821
70822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70823   void * jresult ;
70824   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70825   unsigned int arg2 ;
70826   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70827
70828   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70829   arg2 = (unsigned int)jarg2;
70830   {
70831     try {
70832       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70833     } catch (std::out_of_range& e) {
70834       {
70835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70836       };
70837     } catch (std::exception& e) {
70838       {
70839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70840       };
70841     } catch (Dali::DaliException e) {
70842       {
70843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70844       };
70845     } catch (...) {
70846       {
70847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70848       };
70849     }
70850   }
70851
70852   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70853   return jresult;
70854 }
70855
70856
70857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70858   void * jresult ;
70859   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70860   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70861
70862   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70863   {
70864     try {
70865       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70866     } catch (std::out_of_range& e) {
70867       {
70868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70869       };
70870     } catch (std::exception& e) {
70871       {
70872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70873       };
70874     } catch (Dali::DaliException e) {
70875       {
70876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70877       };
70878     } catch (...) {
70879       {
70880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70881       };
70882     }
70883   }
70884
70885   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70886   return jresult;
70887 }
70888
70889
70890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70891   float jresult ;
70892   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70893   Dali::Toolkit::ItemId arg2 ;
70894   float result;
70895
70896   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70897   arg2 = (Dali::Toolkit::ItemId)jarg2;
70898   {
70899     try {
70900       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70901     } catch (std::out_of_range& e) {
70902       {
70903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70904       };
70905     } catch (std::exception& e) {
70906       {
70907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70908       };
70909     } catch (Dali::DaliException e) {
70910       {
70911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70912       };
70913     } catch (...) {
70914       {
70915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70916       };
70917     }
70918   }
70919
70920   jresult = result;
70921   return jresult;
70922 }
70923
70924
70925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70926   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70927   unsigned int arg2 ;
70928   Dali::Vector3 arg3 ;
70929   float arg4 ;
70930   Dali::Vector3 *argp3 ;
70931
70932   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70933   arg2 = (unsigned int)jarg2;
70934   argp3 = (Dali::Vector3 *)jarg3;
70935   if (!argp3) {
70936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70937     return ;
70938   }
70939   arg3 = *argp3;
70940   arg4 = (float)jarg4;
70941   {
70942     try {
70943       (arg1)->ActivateLayout(arg2,arg3,arg4);
70944     } catch (std::out_of_range& e) {
70945       {
70946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70947       };
70948     } catch (std::exception& e) {
70949       {
70950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70951       };
70952     } catch (Dali::DaliException e) {
70953       {
70954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70955       };
70956     } catch (...) {
70957       {
70958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70959       };
70960     }
70961   }
70962
70963 }
70964
70965
70966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70967   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70968
70969   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70970   {
70971     try {
70972       (arg1)->DeactivateCurrentLayout();
70973     } catch (std::out_of_range& e) {
70974       {
70975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70976       };
70977     } catch (std::exception& e) {
70978       {
70979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70980       };
70981     } catch (Dali::DaliException e) {
70982       {
70983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70984       };
70985     } catch (...) {
70986       {
70987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70988       };
70989     }
70990   }
70991
70992 }
70993
70994
70995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70996   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70997   float arg2 ;
70998
70999   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71000   arg2 = (float)jarg2;
71001   {
71002     try {
71003       (arg1)->SetMinimumSwipeSpeed(arg2);
71004     } catch (std::out_of_range& e) {
71005       {
71006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71007       };
71008     } catch (std::exception& e) {
71009       {
71010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71011       };
71012     } catch (Dali::DaliException e) {
71013       {
71014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71015       };
71016     } catch (...) {
71017       {
71018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71019       };
71020     }
71021   }
71022
71023 }
71024
71025
71026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71027   float jresult ;
71028   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71029   float result;
71030
71031   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71032   {
71033     try {
71034       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71035     } catch (std::out_of_range& e) {
71036       {
71037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71038       };
71039     } catch (std::exception& e) {
71040       {
71041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71042       };
71043     } catch (Dali::DaliException e) {
71044       {
71045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71046       };
71047     } catch (...) {
71048       {
71049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71050       };
71051     }
71052   }
71053
71054   jresult = result;
71055   return jresult;
71056 }
71057
71058
71059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71060   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71061   float arg2 ;
71062
71063   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71064   arg2 = (float)jarg2;
71065   {
71066     try {
71067       (arg1)->SetMinimumSwipeDistance(arg2);
71068     } catch (std::out_of_range& e) {
71069       {
71070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71071       };
71072     } catch (std::exception& e) {
71073       {
71074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71075       };
71076     } catch (Dali::DaliException e) {
71077       {
71078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71079       };
71080     } catch (...) {
71081       {
71082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71083       };
71084     }
71085   }
71086
71087 }
71088
71089
71090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71091   float jresult ;
71092   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71093   float result;
71094
71095   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71096   {
71097     try {
71098       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71099     } catch (std::out_of_range& e) {
71100       {
71101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71102       };
71103     } catch (std::exception& e) {
71104       {
71105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71106       };
71107     } catch (Dali::DaliException e) {
71108       {
71109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71110       };
71111     } catch (...) {
71112       {
71113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71114       };
71115     }
71116   }
71117
71118   jresult = result;
71119   return jresult;
71120 }
71121
71122
71123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71124   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71125   float arg2 ;
71126
71127   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71128   arg2 = (float)jarg2;
71129   {
71130     try {
71131       (arg1)->SetWheelScrollDistanceStep(arg2);
71132     } catch (std::out_of_range& e) {
71133       {
71134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71135       };
71136     } catch (std::exception& e) {
71137       {
71138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71139       };
71140     } catch (Dali::DaliException e) {
71141       {
71142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71143       };
71144     } catch (...) {
71145       {
71146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71147       };
71148     }
71149   }
71150
71151 }
71152
71153
71154 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71155   float jresult ;
71156   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71157   float result;
71158
71159   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71160   {
71161     try {
71162       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71163     } catch (std::out_of_range& e) {
71164       {
71165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71166       };
71167     } catch (std::exception& e) {
71168       {
71169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71170       };
71171     } catch (Dali::DaliException e) {
71172       {
71173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71174       };
71175     } catch (...) {
71176       {
71177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71178       };
71179     }
71180   }
71181
71182   jresult = result;
71183   return jresult;
71184 }
71185
71186
71187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71188   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71189   bool arg2 ;
71190
71191   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71192   arg2 = jarg2 ? true : false;
71193   {
71194     try {
71195       (arg1)->SetAnchoring(arg2);
71196     } catch (std::out_of_range& e) {
71197       {
71198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71199       };
71200     } catch (std::exception& e) {
71201       {
71202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71203       };
71204     } catch (Dali::DaliException e) {
71205       {
71206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71207       };
71208     } catch (...) {
71209       {
71210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71211       };
71212     }
71213   }
71214
71215 }
71216
71217 //// ========================= end of part 3 =============================
71218
71219 //// ========================== start part 4 ===============================
71220
71221
71222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71223   unsigned int jresult ;
71224   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71225   bool result;
71226
71227   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71228   {
71229     try {
71230       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71231     } catch (std::out_of_range& e) {
71232       {
71233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71234       };
71235     } catch (std::exception& e) {
71236       {
71237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71238       };
71239     } catch (Dali::DaliException e) {
71240       {
71241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71242       };
71243     } catch (...) {
71244       {
71245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71246       };
71247     }
71248   }
71249
71250   jresult = result;
71251   return jresult;
71252 }
71253
71254
71255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71256   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71257   float arg2 ;
71258
71259   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71260   arg2 = (float)jarg2;
71261   {
71262     try {
71263       (arg1)->SetAnchoringDuration(arg2);
71264     } catch (std::out_of_range& e) {
71265       {
71266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71267       };
71268     } catch (std::exception& e) {
71269       {
71270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71271       };
71272     } catch (Dali::DaliException e) {
71273       {
71274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71275       };
71276     } catch (...) {
71277       {
71278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71279       };
71280     }
71281   }
71282
71283 }
71284
71285
71286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71287   float jresult ;
71288   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71289   float result;
71290
71291   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71292   {
71293     try {
71294       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71295     } catch (std::out_of_range& e) {
71296       {
71297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71298       };
71299     } catch (std::exception& e) {
71300       {
71301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71302       };
71303     } catch (Dali::DaliException e) {
71304       {
71305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71306       };
71307     } catch (...) {
71308       {
71309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71310       };
71311     }
71312   }
71313
71314   jresult = result;
71315   return jresult;
71316 }
71317
71318
71319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71320   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71321   Dali::Toolkit::ItemId arg2 ;
71322   float arg3 ;
71323
71324   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71325   arg2 = (Dali::Toolkit::ItemId)jarg2;
71326   arg3 = (float)jarg3;
71327   {
71328     try {
71329       (arg1)->ScrollToItem(arg2,arg3);
71330     } catch (std::out_of_range& e) {
71331       {
71332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71333       };
71334     } catch (std::exception& e) {
71335       {
71336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71337       };
71338     } catch (Dali::DaliException e) {
71339       {
71340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71341       };
71342     } catch (...) {
71343       {
71344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71345       };
71346     }
71347   }
71348
71349 }
71350
71351
71352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71353   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71354   float arg2 ;
71355
71356   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71357   arg2 = (float)jarg2;
71358   {
71359     try {
71360       (arg1)->SetRefreshInterval(arg2);
71361     } catch (std::out_of_range& e) {
71362       {
71363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71364       };
71365     } catch (std::exception& e) {
71366       {
71367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71368       };
71369     } catch (Dali::DaliException e) {
71370       {
71371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71372       };
71373     } catch (...) {
71374       {
71375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71376       };
71377     }
71378   }
71379
71380 }
71381
71382
71383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71384   float jresult ;
71385   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71386   float result;
71387
71388   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71389   {
71390     try {
71391       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71392     } catch (std::out_of_range& e) {
71393       {
71394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71395       };
71396     } catch (std::exception& e) {
71397       {
71398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71399       };
71400     } catch (Dali::DaliException e) {
71401       {
71402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71403       };
71404     } catch (...) {
71405       {
71406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71407       };
71408     }
71409   }
71410
71411   jresult = result;
71412   return jresult;
71413 }
71414
71415
71416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71417   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71418
71419   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71420   {
71421     try {
71422       (arg1)->Refresh();
71423     } catch (std::out_of_range& e) {
71424       {
71425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71426       };
71427     } catch (std::exception& e) {
71428       {
71429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71430       };
71431     } catch (Dali::DaliException e) {
71432       {
71433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71434       };
71435     } catch (...) {
71436       {
71437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71438       };
71439     }
71440   }
71441
71442 }
71443
71444
71445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71446   void * jresult ;
71447   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71448   Dali::Toolkit::ItemId arg2 ;
71449   Dali::Actor result;
71450
71451   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71452   arg2 = (Dali::Toolkit::ItemId)jarg2;
71453   {
71454     try {
71455       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71456     } catch (std::out_of_range& e) {
71457       {
71458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71459       };
71460     } catch (std::exception& e) {
71461       {
71462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71463       };
71464     } catch (Dali::DaliException e) {
71465       {
71466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71467       };
71468     } catch (...) {
71469       {
71470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71471       };
71472     }
71473   }
71474
71475   jresult = new Dali::Actor((const Dali::Actor &)result);
71476   return jresult;
71477 }
71478
71479
71480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71481   unsigned int jresult ;
71482   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71483   Dali::Actor arg2 ;
71484   Dali::Actor *argp2 ;
71485   Dali::Toolkit::ItemId result;
71486
71487   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71488   argp2 = (Dali::Actor *)jarg2;
71489   if (!argp2) {
71490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71491     return 0;
71492   }
71493   arg2 = *argp2;
71494   {
71495     try {
71496       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71497     } catch (std::out_of_range& e) {
71498       {
71499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71500       };
71501     } catch (std::exception& e) {
71502       {
71503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71504       };
71505     } catch (Dali::DaliException e) {
71506       {
71507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71508       };
71509     } catch (...) {
71510       {
71511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71512       };
71513     }
71514   }
71515
71516   jresult = result;
71517   return jresult;
71518 }
71519
71520
71521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71522   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71523   Dali::Toolkit::Item arg2 ;
71524   float arg3 ;
71525   Dali::Toolkit::Item *argp2 ;
71526
71527   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71528   argp2 = (Dali::Toolkit::Item *)jarg2;
71529   if (!argp2) {
71530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71531     return ;
71532   }
71533   arg2 = *argp2;
71534   arg3 = (float)jarg3;
71535   {
71536     try {
71537       (arg1)->InsertItem(arg2,arg3);
71538     } catch (std::out_of_range& e) {
71539       {
71540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71541       };
71542     } catch (std::exception& e) {
71543       {
71544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71545       };
71546     } catch (Dali::DaliException e) {
71547       {
71548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71549       };
71550     } catch (...) {
71551       {
71552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71553       };
71554     }
71555   }
71556
71557 }
71558
71559
71560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71561   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71562   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71563   float arg3 ;
71564
71565   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71566   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71567   if (!arg2) {
71568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71569     return ;
71570   }
71571   arg3 = (float)jarg3;
71572   {
71573     try {
71574       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71575     } catch (std::out_of_range& e) {
71576       {
71577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71578       };
71579     } catch (std::exception& e) {
71580       {
71581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71582       };
71583     } catch (Dali::DaliException e) {
71584       {
71585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71586       };
71587     } catch (...) {
71588       {
71589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71590       };
71591     }
71592   }
71593
71594 }
71595
71596
71597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71598   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71599   Dali::Toolkit::ItemId arg2 ;
71600   float arg3 ;
71601
71602   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71603   arg2 = (Dali::Toolkit::ItemId)jarg2;
71604   arg3 = (float)jarg3;
71605   {
71606     try {
71607       (arg1)->RemoveItem(arg2,arg3);
71608     } catch (std::out_of_range& e) {
71609       {
71610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71611       };
71612     } catch (std::exception& e) {
71613       {
71614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71615       };
71616     } catch (Dali::DaliException e) {
71617       {
71618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71619       };
71620     } catch (...) {
71621       {
71622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71623       };
71624     }
71625   }
71626
71627 }
71628
71629
71630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71631   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71632   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71633   float arg3 ;
71634
71635   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71636   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71637   if (!arg2) {
71638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71639     return ;
71640   }
71641   arg3 = (float)jarg3;
71642   {
71643     try {
71644       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71645     } catch (std::out_of_range& e) {
71646       {
71647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71648       };
71649     } catch (std::exception& e) {
71650       {
71651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71652       };
71653     } catch (Dali::DaliException e) {
71654       {
71655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71656       };
71657     } catch (...) {
71658       {
71659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71660       };
71661     }
71662   }
71663
71664 }
71665
71666
71667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71668   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71669   Dali::Toolkit::Item arg2 ;
71670   float arg3 ;
71671   Dali::Toolkit::Item *argp2 ;
71672
71673   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71674   argp2 = (Dali::Toolkit::Item *)jarg2;
71675   if (!argp2) {
71676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71677     return ;
71678   }
71679   arg2 = *argp2;
71680   arg3 = (float)jarg3;
71681   {
71682     try {
71683       (arg1)->ReplaceItem(arg2,arg3);
71684     } catch (std::out_of_range& e) {
71685       {
71686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71687       };
71688     } catch (std::exception& e) {
71689       {
71690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71691       };
71692     } catch (Dali::DaliException e) {
71693       {
71694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71695       };
71696     } catch (...) {
71697       {
71698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71699       };
71700     }
71701   }
71702
71703 }
71704
71705
71706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71707   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71708   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71709   float arg3 ;
71710
71711   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71712   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71713   if (!arg2) {
71714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71715     return ;
71716   }
71717   arg3 = (float)jarg3;
71718   {
71719     try {
71720       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71721     } catch (std::out_of_range& e) {
71722       {
71723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71724       };
71725     } catch (std::exception& e) {
71726       {
71727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71728       };
71729     } catch (Dali::DaliException e) {
71730       {
71731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71732       };
71733     } catch (...) {
71734       {
71735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71736       };
71737     }
71738   }
71739
71740 }
71741
71742
71743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71744   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71745   Dali::Vector3 *arg2 = 0 ;
71746
71747   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71748   arg2 = (Dali::Vector3 *)jarg2;
71749   if (!arg2) {
71750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71751     return ;
71752   }
71753   {
71754     try {
71755       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71756     } catch (std::out_of_range& e) {
71757       {
71758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71759       };
71760     } catch (std::exception& e) {
71761       {
71762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71763       };
71764     } catch (Dali::DaliException e) {
71765       {
71766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71767       };
71768     } catch (...) {
71769       {
71770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71771       };
71772     }
71773   }
71774
71775 }
71776
71777
71778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71779   void * jresult ;
71780   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71781   Dali::Vector3 result;
71782
71783   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71784   {
71785     try {
71786       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71787     } catch (std::out_of_range& e) {
71788       {
71789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71790       };
71791     } catch (std::exception& e) {
71792       {
71793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71794       };
71795     } catch (Dali::DaliException e) {
71796       {
71797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71798       };
71799     } catch (...) {
71800       {
71801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71802       };
71803     }
71804   }
71805
71806   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71807   return jresult;
71808 }
71809
71810
71811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71812   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71813   Dali::Vector3 *arg2 = 0 ;
71814
71815   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71816   arg2 = (Dali::Vector3 *)jarg2;
71817   if (!arg2) {
71818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71819     return ;
71820   }
71821   {
71822     try {
71823       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71824     } catch (std::out_of_range& e) {
71825       {
71826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71827       };
71828     } catch (std::exception& e) {
71829       {
71830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71831       };
71832     } catch (Dali::DaliException e) {
71833       {
71834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71835       };
71836     } catch (...) {
71837       {
71838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71839       };
71840     }
71841   }
71842
71843 }
71844
71845
71846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71847   void * jresult ;
71848   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71849   Dali::Vector3 result;
71850
71851   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71852   {
71853     try {
71854       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71855     } catch (std::out_of_range& e) {
71856       {
71857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71858       };
71859     } catch (std::exception& e) {
71860       {
71861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71862       };
71863     } catch (Dali::DaliException e) {
71864       {
71865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71866       };
71867     } catch (...) {
71868       {
71869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71870       };
71871     }
71872   }
71873
71874   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71875   return jresult;
71876 }
71877
71878
71879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71880   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71881   Dali::Toolkit::ItemRange *arg2 = 0 ;
71882
71883   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71884   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71885   if (!arg2) {
71886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71887     return ;
71888   }
71889   {
71890     try {
71891       (arg1)->GetItemsRange(*arg2);
71892     } catch (std::out_of_range& e) {
71893       {
71894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71895       };
71896     } catch (std::exception& e) {
71897       {
71898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71899       };
71900     } catch (Dali::DaliException e) {
71901       {
71902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71903       };
71904     } catch (...) {
71905       {
71906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71907       };
71908     }
71909   }
71910
71911 }
71912
71913
71914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71915   void * jresult ;
71916   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71917   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71918
71919   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71920   {
71921     try {
71922       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71923     } catch (std::out_of_range& e) {
71924       {
71925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71926       };
71927     } catch (std::exception& e) {
71928       {
71929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71930       };
71931     } catch (Dali::DaliException e) {
71932       {
71933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71934       };
71935     } catch (...) {
71936       {
71937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71938       };
71939     }
71940   }
71941
71942   jresult = (void *)result;
71943   return jresult;
71944 }
71945
71946
71947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
71948   Dali::Vector3 *arg1 = 0 ;
71949   PropertyInputContainer *arg2 = 0 ;
71950
71951   arg1 = (Dali::Vector3 *)jarg1;
71952   if (!arg1) {
71953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71954     return ;
71955   }
71956   arg2 = (PropertyInputContainer *)jarg2;
71957   if (!arg2) {
71958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71959     return ;
71960   }
71961   {
71962     try {
71963       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71964     } catch (std::out_of_range& e) {
71965       {
71966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71967       };
71968     } catch (std::exception& e) {
71969       {
71970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71971       };
71972     } catch (Dali::DaliException e) {
71973       {
71974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71975       };
71976     } catch (...) {
71977       {
71978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71979       };
71980     }
71981   }
71982
71983 }
71984
71985
71986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71987   Dali::Vector3 *arg1 = 0 ;
71988   PropertyInputContainer *arg2 = 0 ;
71989
71990   arg1 = (Dali::Vector3 *)jarg1;
71991   if (!arg1) {
71992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71993     return ;
71994   }
71995   arg2 = (PropertyInputContainer *)jarg2;
71996   if (!arg2) {
71997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71998     return ;
71999   }
72000   {
72001     try {
72002       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72003     } catch (std::out_of_range& e) {
72004       {
72005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72006       };
72007     } catch (std::exception& e) {
72008       {
72009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72010       };
72011     } catch (Dali::DaliException e) {
72012       {
72013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72014       };
72015     } catch (...) {
72016       {
72017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72018       };
72019     }
72020   }
72021
72022 }
72023
72024
72025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72026   void * jresult ;
72027   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72028
72029   {
72030     try {
72031       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72032     } catch (std::out_of_range& e) {
72033       {
72034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72035       };
72036     } catch (std::exception& e) {
72037       {
72038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72039       };
72040     } catch (Dali::DaliException e) {
72041       {
72042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72043       };
72044     } catch (...) {
72045       {
72046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72047       };
72048     }
72049   }
72050
72051   jresult = (void *)result;
72052   return jresult;
72053 }
72054
72055
72056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72057   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72058
72059   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72060   {
72061     try {
72062       delete arg1;
72063     } catch (std::out_of_range& e) {
72064       {
72065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72066       };
72067     } catch (std::exception& e) {
72068       {
72069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72070       };
72071     } catch (Dali::DaliException e) {
72072       {
72073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72074       };
72075     } catch (...) {
72076       {
72077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72078       };
72079     }
72080   }
72081
72082 }
72083
72084
72085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72086   void * jresult ;
72087   Dali::Path arg1 ;
72088   Dali::Vector3 *arg2 = 0 ;
72089   Dali::Property::Index arg3 ;
72090   Dali::Vector3 *arg4 = 0 ;
72091   unsigned int arg5 ;
72092   Dali::Path *argp1 ;
72093   Dali::Toolkit::ScrollViewPagePathEffect result;
72094
72095   argp1 = (Dali::Path *)jarg1;
72096   if (!argp1) {
72097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72098     return 0;
72099   }
72100   arg1 = *argp1;
72101   arg2 = (Dali::Vector3 *)jarg2;
72102   if (!arg2) {
72103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72104     return 0;
72105   }
72106   arg3 = (Dali::Property::Index)jarg3;
72107   arg4 = (Dali::Vector3 *)jarg4;
72108   if (!arg4) {
72109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72110     return 0;
72111   }
72112   arg5 = (unsigned int)jarg5;
72113   {
72114     try {
72115       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72116     } catch (std::out_of_range& e) {
72117       {
72118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72119       };
72120     } catch (std::exception& e) {
72121       {
72122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72123       };
72124     } catch (Dali::DaliException e) {
72125       {
72126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72127       };
72128     } catch (...) {
72129       {
72130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72131       };
72132     }
72133   }
72134
72135   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72136   return jresult;
72137 }
72138
72139
72140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72141   void * jresult ;
72142   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72143
72144   {
72145     try {
72146       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72147     } catch (std::out_of_range& e) {
72148       {
72149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72150       };
72151     } catch (std::exception& e) {
72152       {
72153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72154       };
72155     } catch (Dali::DaliException e) {
72156       {
72157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72158       };
72159     } catch (...) {
72160       {
72161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72162       };
72163     }
72164   }
72165
72166   jresult = (void *)result;
72167   return jresult;
72168 }
72169
72170
72171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72172   void * jresult ;
72173   Dali::BaseHandle arg1 ;
72174   Dali::BaseHandle *argp1 ;
72175   Dali::Toolkit::ScrollViewPagePathEffect result;
72176
72177   argp1 = (Dali::BaseHandle *)jarg1;
72178   if (!argp1) {
72179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72180     return 0;
72181   }
72182   arg1 = *argp1;
72183   {
72184     try {
72185       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72186     } catch (std::out_of_range& e) {
72187       {
72188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72189       };
72190     } catch (std::exception& e) {
72191       {
72192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72193       };
72194     } catch (Dali::DaliException e) {
72195       {
72196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72197       };
72198     } catch (...) {
72199       {
72200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72201       };
72202     }
72203   }
72204
72205   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72206   return jresult;
72207 }
72208
72209
72210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72211   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72212   Dali::Actor arg2 ;
72213   unsigned int arg3 ;
72214   Dali::Actor *argp2 ;
72215
72216   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72217   argp2 = (Dali::Actor *)jarg2;
72218   if (!argp2) {
72219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72220     return ;
72221   }
72222   arg2 = *argp2;
72223   arg3 = (unsigned int)jarg3;
72224   {
72225     try {
72226       (arg1)->ApplyToPage(arg2,arg3);
72227     } catch (std::out_of_range& e) {
72228       {
72229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72230       };
72231     } catch (std::exception& e) {
72232       {
72233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72234       };
72235     } catch (Dali::DaliException e) {
72236       {
72237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72238       };
72239     } catch (...) {
72240       {
72241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72242       };
72243     }
72244   }
72245
72246 }
72247
72248
72249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72250   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72251
72252   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72253   {
72254     try {
72255       delete arg1;
72256     } catch (std::out_of_range& e) {
72257       {
72258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72259       };
72260     } catch (std::exception& e) {
72261       {
72262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72263       };
72264     } catch (Dali::DaliException e) {
72265       {
72266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72267       };
72268     } catch (...) {
72269       {
72270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72271       };
72272     }
72273   }
72274
72275 }
72276
72277
72278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72279   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72280   Dali::Toolkit::ClampState arg2 ;
72281
72282   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72283   arg2 = (Dali::Toolkit::ClampState)jarg2;
72284   if (arg1) (arg1)->x = arg2;
72285 }
72286
72287
72288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72289   int jresult ;
72290   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72291   Dali::Toolkit::ClampState result;
72292
72293   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72294   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72295   jresult = (int)result;
72296   return jresult;
72297 }
72298
72299
72300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72301   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72302   Dali::Toolkit::ClampState arg2 ;
72303
72304   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72305   arg2 = (Dali::Toolkit::ClampState)jarg2;
72306   if (arg1) (arg1)->y = arg2;
72307 }
72308
72309
72310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72311   int jresult ;
72312   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72313   Dali::Toolkit::ClampState result;
72314
72315   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72316   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72317   jresult = (int)result;
72318   return jresult;
72319 }
72320
72321
72322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72323   void * jresult ;
72324   Dali::Toolkit::ClampState2D *result = 0 ;
72325
72326   {
72327     try {
72328       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72329     } catch (std::out_of_range& e) {
72330       {
72331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72332       };
72333     } catch (std::exception& e) {
72334       {
72335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72336       };
72337     } catch (Dali::DaliException e) {
72338       {
72339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72340       };
72341     } catch (...) {
72342       {
72343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72344       };
72345     }
72346   }
72347
72348   jresult = (void *)result;
72349   return jresult;
72350 }
72351
72352
72353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72354   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72355
72356   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72357   {
72358     try {
72359       delete arg1;
72360     } catch (std::out_of_range& e) {
72361       {
72362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72363       };
72364     } catch (std::exception& e) {
72365       {
72366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72367       };
72368     } catch (Dali::DaliException e) {
72369       {
72370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72371       };
72372     } catch (...) {
72373       {
72374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72375       };
72376     }
72377   }
72378
72379 }
72380
72381
72382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72383   void * jresult ;
72384   float arg1 ;
72385   float arg2 ;
72386   bool arg3 ;
72387   Dali::Toolkit::RulerDomain *result = 0 ;
72388
72389   arg1 = (float)jarg1;
72390   arg2 = (float)jarg2;
72391   arg3 = jarg3 ? true : false;
72392   {
72393     try {
72394       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72395     } catch (std::out_of_range& e) {
72396       {
72397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72398       };
72399     } catch (std::exception& e) {
72400       {
72401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72402       };
72403     } catch (Dali::DaliException e) {
72404       {
72405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72406       };
72407     } catch (...) {
72408       {
72409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72410       };
72411     }
72412   }
72413
72414   jresult = (void *)result;
72415   return jresult;
72416 }
72417
72418
72419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72420   void * jresult ;
72421   float arg1 ;
72422   float arg2 ;
72423   Dali::Toolkit::RulerDomain *result = 0 ;
72424
72425   arg1 = (float)jarg1;
72426   arg2 = (float)jarg2;
72427   {
72428     try {
72429       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72430     } catch (std::out_of_range& e) {
72431       {
72432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72433       };
72434     } catch (std::exception& e) {
72435       {
72436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72437       };
72438     } catch (Dali::DaliException e) {
72439       {
72440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72441       };
72442     } catch (...) {
72443       {
72444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72445       };
72446     }
72447   }
72448
72449   jresult = (void *)result;
72450   return jresult;
72451 }
72452
72453
72454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72455   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72456   float arg2 ;
72457
72458   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72459   arg2 = (float)jarg2;
72460   if (arg1) (arg1)->min = arg2;
72461 }
72462
72463
72464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72465   float jresult ;
72466   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72467   float result;
72468
72469   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72470   result = (float) ((arg1)->min);
72471   jresult = result;
72472   return jresult;
72473 }
72474
72475
72476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72477   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72478   float arg2 ;
72479
72480   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72481   arg2 = (float)jarg2;
72482   if (arg1) (arg1)->max = arg2;
72483 }
72484
72485
72486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72487   float jresult ;
72488   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72489   float result;
72490
72491   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72492   result = (float) ((arg1)->max);
72493   jresult = result;
72494   return jresult;
72495 }
72496
72497
72498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72499   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72500   bool arg2 ;
72501
72502   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72503   arg2 = jarg2 ? true : false;
72504   if (arg1) (arg1)->enabled = arg2;
72505 }
72506
72507
72508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72509   unsigned int jresult ;
72510   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72511   bool result;
72512
72513   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72514   result = (bool) ((arg1)->enabled);
72515   jresult = result;
72516   return jresult;
72517 }
72518
72519
72520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72521   float jresult ;
72522   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72523   float arg2 ;
72524   float arg3 ;
72525   float arg4 ;
72526   float result;
72527
72528   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72529   arg2 = (float)jarg2;
72530   arg3 = (float)jarg3;
72531   arg4 = (float)jarg4;
72532   {
72533     try {
72534       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
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 float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72560   float jresult ;
72561   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72562   float arg2 ;
72563   float arg3 ;
72564   float result;
72565
72566   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72567   arg2 = (float)jarg2;
72568   arg3 = (float)jarg3;
72569   {
72570     try {
72571       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72572     } catch (std::out_of_range& e) {
72573       {
72574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72575       };
72576     } catch (std::exception& e) {
72577       {
72578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72579       };
72580     } catch (Dali::DaliException e) {
72581       {
72582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72583       };
72584     } catch (...) {
72585       {
72586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72587       };
72588     }
72589   }
72590
72591   jresult = result;
72592   return jresult;
72593 }
72594
72595
72596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72597   float jresult ;
72598   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72599   float arg2 ;
72600   float result;
72601
72602   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72603   arg2 = (float)jarg2;
72604   {
72605     try {
72606       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72607     } catch (std::out_of_range& e) {
72608       {
72609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72610       };
72611     } catch (std::exception& e) {
72612       {
72613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72614       };
72615     } catch (Dali::DaliException e) {
72616       {
72617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72618       };
72619     } catch (...) {
72620       {
72621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72622       };
72623     }
72624   }
72625
72626   jresult = result;
72627   return jresult;
72628 }
72629
72630
72631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72632   float jresult ;
72633   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72634   float arg2 ;
72635   float arg3 ;
72636   float arg4 ;
72637   Dali::Toolkit::ClampState *arg5 = 0 ;
72638   float result;
72639
72640   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72641   arg2 = (float)jarg2;
72642   arg3 = (float)jarg3;
72643   arg4 = (float)jarg4;
72644   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72645   if (!arg5) {
72646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72647     return 0;
72648   }
72649   {
72650     try {
72651       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72652     } catch (std::out_of_range& e) {
72653       {
72654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72655       };
72656     } catch (std::exception& e) {
72657       {
72658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72659       };
72660     } catch (Dali::DaliException e) {
72661       {
72662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72663       };
72664     } catch (...) {
72665       {
72666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72667       };
72668     }
72669   }
72670
72671   jresult = result;
72672   return jresult;
72673 }
72674
72675
72676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72677   float jresult ;
72678   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72679   float result;
72680
72681   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72682   {
72683     try {
72684       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72685     } catch (std::out_of_range& e) {
72686       {
72687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72688       };
72689     } catch (std::exception& e) {
72690       {
72691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72692       };
72693     } catch (Dali::DaliException e) {
72694       {
72695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72696       };
72697     } catch (...) {
72698       {
72699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72700       };
72701     }
72702   }
72703
72704   jresult = result;
72705   return jresult;
72706 }
72707
72708
72709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72710   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72711
72712   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72713   {
72714     try {
72715       delete arg1;
72716     } catch (std::out_of_range& e) {
72717       {
72718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72719       };
72720     } catch (std::exception& e) {
72721       {
72722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72723       };
72724     } catch (Dali::DaliException e) {
72725       {
72726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72727       };
72728     } catch (...) {
72729       {
72730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72731       };
72732     }
72733   }
72734
72735 }
72736
72737
72738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72739   float jresult ;
72740   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72741   float arg2 ;
72742   float arg3 ;
72743   float result;
72744
72745   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72746   arg2 = (float)jarg2;
72747   arg3 = (float)jarg3;
72748   {
72749     try {
72750       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72751     } catch (std::out_of_range& e) {
72752       {
72753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72754       };
72755     } catch (std::exception& e) {
72756       {
72757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72758       };
72759     } catch (Dali::DaliException e) {
72760       {
72761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72762       };
72763     } catch (...) {
72764       {
72765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72766       };
72767     }
72768   }
72769
72770   jresult = result;
72771   return jresult;
72772 }
72773
72774
72775 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72776   float jresult ;
72777   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72778   float arg2 ;
72779   float result;
72780
72781   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72782   arg2 = (float)jarg2;
72783   {
72784     try {
72785       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72786     } catch (std::out_of_range& e) {
72787       {
72788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72789       };
72790     } catch (std::exception& e) {
72791       {
72792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72793       };
72794     } catch (Dali::DaliException e) {
72795       {
72796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72797       };
72798     } catch (...) {
72799       {
72800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72801       };
72802     }
72803   }
72804
72805   jresult = result;
72806   return jresult;
72807 }
72808
72809
72810 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72811   float jresult ;
72812   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72813   unsigned int arg2 ;
72814   unsigned int *arg3 = 0 ;
72815   bool arg4 ;
72816   float result;
72817
72818   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72819   arg2 = (unsigned int)jarg2;
72820   arg3 = (unsigned int *)jarg3;
72821   arg4 = jarg4 ? true : false;
72822   {
72823     try {
72824       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72825     } catch (std::out_of_range& e) {
72826       {
72827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72828       };
72829     } catch (std::exception& e) {
72830       {
72831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72832       };
72833     } catch (Dali::DaliException e) {
72834       {
72835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72836       };
72837     } catch (...) {
72838       {
72839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72840       };
72841     }
72842   }
72843
72844   jresult = result;
72845   return jresult;
72846 }
72847
72848
72849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72850   unsigned int jresult ;
72851   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72852   float arg2 ;
72853   bool arg3 ;
72854   unsigned int result;
72855
72856   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72857   arg2 = (float)jarg2;
72858   arg3 = jarg3 ? true : false;
72859   {
72860     try {
72861       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72862     } catch (std::out_of_range& e) {
72863       {
72864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72865       };
72866     } catch (std::exception& e) {
72867       {
72868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72869       };
72870     } catch (Dali::DaliException e) {
72871       {
72872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72873       };
72874     } catch (...) {
72875       {
72876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72877       };
72878     }
72879   }
72880
72881   jresult = result;
72882   return jresult;
72883 }
72884
72885
72886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72887   unsigned int jresult ;
72888   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72889   unsigned int result;
72890
72891   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72892   {
72893     try {
72894       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72895     } catch (std::out_of_range& e) {
72896       {
72897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72898       };
72899     } catch (std::exception& e) {
72900       {
72901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72902       };
72903     } catch (Dali::DaliException e) {
72904       {
72905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72906       };
72907     } catch (...) {
72908       {
72909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72910       };
72911     }
72912   }
72913
72914   jresult = result;
72915   return jresult;
72916 }
72917
72918
72919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72920   int jresult ;
72921   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72922   Dali::Toolkit::Ruler::RulerType result;
72923
72924   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72925   {
72926     try {
72927       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72928     } catch (std::out_of_range& e) {
72929       {
72930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72931       };
72932     } catch (std::exception& e) {
72933       {
72934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72935       };
72936     } catch (Dali::DaliException e) {
72937       {
72938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72939       };
72940     } catch (...) {
72941       {
72942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72943       };
72944     }
72945   }
72946
72947   jresult = (int)result;
72948   return jresult;
72949 }
72950
72951
72952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72953   unsigned int jresult ;
72954   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72955   bool result;
72956
72957   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72958   {
72959     try {
72960       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72961     } catch (std::out_of_range& e) {
72962       {
72963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72964       };
72965     } catch (std::exception& e) {
72966       {
72967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72968       };
72969     } catch (Dali::DaliException e) {
72970       {
72971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72972       };
72973     } catch (...) {
72974       {
72975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72976       };
72977     }
72978   }
72979
72980   jresult = result;
72981   return jresult;
72982 }
72983
72984
72985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72986   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72987
72988   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72989   {
72990     try {
72991       (arg1)->Enable();
72992     } catch (std::out_of_range& e) {
72993       {
72994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72995       };
72996     } catch (std::exception& e) {
72997       {
72998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72999       };
73000     } catch (Dali::DaliException e) {
73001       {
73002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73003       };
73004     } catch (...) {
73005       {
73006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73007       };
73008     }
73009   }
73010
73011 }
73012
73013
73014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
73015   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73016
73017   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73018   {
73019     try {
73020       (arg1)->Disable();
73021     } catch (std::out_of_range& e) {
73022       {
73023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73024       };
73025     } catch (std::exception& e) {
73026       {
73027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73028       };
73029     } catch (Dali::DaliException e) {
73030       {
73031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73032       };
73033     } catch (...) {
73034       {
73035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73036       };
73037     }
73038   }
73039
73040 }
73041
73042
73043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73044   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73045   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73046   Dali::Toolkit::RulerDomain *argp2 ;
73047
73048   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73049   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73050   if (!argp2) {
73051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73052     return ;
73053   }
73054   arg2 = *argp2;
73055   {
73056     try {
73057       (arg1)->SetDomain(arg2);
73058     } catch (std::out_of_range& e) {
73059       {
73060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73061       };
73062     } catch (std::exception& e) {
73063       {
73064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73065       };
73066     } catch (Dali::DaliException e) {
73067       {
73068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73069       };
73070     } catch (...) {
73071       {
73072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73073       };
73074     }
73075   }
73076
73077 }
73078
73079
73080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73081   void * jresult ;
73082   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73083   Dali::Toolkit::RulerDomain *result = 0 ;
73084
73085   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73086   {
73087     try {
73088       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73089     } catch (std::out_of_range& e) {
73090       {
73091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73092       };
73093     } catch (std::exception& e) {
73094       {
73095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73096       };
73097     } catch (Dali::DaliException e) {
73098       {
73099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73100       };
73101     } catch (...) {
73102       {
73103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73104       };
73105     }
73106   }
73107
73108   jresult = (void *)result;
73109   return jresult;
73110 }
73111
73112
73113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73114   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73115
73116   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73117   {
73118     try {
73119       (arg1)->DisableDomain();
73120     } catch (std::out_of_range& e) {
73121       {
73122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73123       };
73124     } catch (std::exception& e) {
73125       {
73126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73127       };
73128     } catch (Dali::DaliException e) {
73129       {
73130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73131       };
73132     } catch (...) {
73133       {
73134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73135       };
73136     }
73137   }
73138
73139 }
73140
73141
73142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73143   float jresult ;
73144   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73145   float arg2 ;
73146   float arg3 ;
73147   float arg4 ;
73148   float result;
73149
73150   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73151   arg2 = (float)jarg2;
73152   arg3 = (float)jarg3;
73153   arg4 = (float)jarg4;
73154   {
73155     try {
73156       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73157     } catch (std::out_of_range& e) {
73158       {
73159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73160       };
73161     } catch (std::exception& e) {
73162       {
73163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73164       };
73165     } catch (Dali::DaliException e) {
73166       {
73167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73168       };
73169     } catch (...) {
73170       {
73171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73172       };
73173     }
73174   }
73175
73176   jresult = result;
73177   return jresult;
73178 }
73179
73180
73181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73182   float jresult ;
73183   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73184   float arg2 ;
73185   float arg3 ;
73186   float result;
73187
73188   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73189   arg2 = (float)jarg2;
73190   arg3 = (float)jarg3;
73191   {
73192     try {
73193       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73194     } catch (std::out_of_range& e) {
73195       {
73196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73197       };
73198     } catch (std::exception& e) {
73199       {
73200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73201       };
73202     } catch (Dali::DaliException e) {
73203       {
73204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73205       };
73206     } catch (...) {
73207       {
73208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73209       };
73210     }
73211   }
73212
73213   jresult = result;
73214   return jresult;
73215 }
73216
73217
73218 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73219   float jresult ;
73220   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73221   float arg2 ;
73222   float result;
73223
73224   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73225   arg2 = (float)jarg2;
73226   {
73227     try {
73228       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73229     } catch (std::out_of_range& e) {
73230       {
73231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73232       };
73233     } catch (std::exception& e) {
73234       {
73235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73236       };
73237     } catch (Dali::DaliException e) {
73238       {
73239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73240       };
73241     } catch (...) {
73242       {
73243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73244       };
73245     }
73246   }
73247
73248   jresult = result;
73249   return jresult;
73250 }
73251
73252
73253 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73254   float jresult ;
73255   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73256   float arg2 ;
73257   float arg3 ;
73258   float arg4 ;
73259   Dali::Toolkit::ClampState *arg5 = 0 ;
73260   float result;
73261
73262   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73263   arg2 = (float)jarg2;
73264   arg3 = (float)jarg3;
73265   arg4 = (float)jarg4;
73266   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73267   if (!arg5) {
73268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73269     return 0;
73270   }
73271   {
73272     try {
73273       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73274     } catch (std::out_of_range& e) {
73275       {
73276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73277       };
73278     } catch (std::exception& e) {
73279       {
73280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73281       };
73282     } catch (Dali::DaliException e) {
73283       {
73284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73285       };
73286     } catch (...) {
73287       {
73288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73289       };
73290     }
73291   }
73292
73293   jresult = result;
73294   return jresult;
73295 }
73296
73297
73298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73299   float jresult ;
73300   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73301   float arg2 ;
73302   float arg3 ;
73303   float arg4 ;
73304   float arg5 ;
73305   float result;
73306
73307   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73308   arg2 = (float)jarg2;
73309   arg3 = (float)jarg3;
73310   arg4 = (float)jarg4;
73311   arg5 = (float)jarg5;
73312   {
73313     try {
73314       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73315     } catch (std::out_of_range& e) {
73316       {
73317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73318       };
73319     } catch (std::exception& e) {
73320       {
73321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73322       };
73323     } catch (Dali::DaliException e) {
73324       {
73325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73326       };
73327     } catch (...) {
73328       {
73329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73330       };
73331     }
73332   }
73333
73334   jresult = result;
73335   return jresult;
73336 }
73337
73338
73339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73340   float jresult ;
73341   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73342   float arg2 ;
73343   float arg3 ;
73344   float arg4 ;
73345   float result;
73346
73347   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73348   arg2 = (float)jarg2;
73349   arg3 = (float)jarg3;
73350   arg4 = (float)jarg4;
73351   {
73352     try {
73353       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
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 = result;
73374   return jresult;
73375 }
73376
73377
73378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73379   float jresult ;
73380   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73381   float arg2 ;
73382   float arg3 ;
73383   float result;
73384
73385   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73386   arg2 = (float)jarg2;
73387   arg3 = (float)jarg3;
73388   {
73389     try {
73390       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(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_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73416   float jresult ;
73417   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73418   float arg2 ;
73419   float result;
73420
73421   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73422   arg2 = (float)jarg2;
73423   {
73424     try {
73425       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73426     } catch (std::out_of_range& e) {
73427       {
73428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73429       };
73430     } catch (std::exception& e) {
73431       {
73432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73433       };
73434     } catch (Dali::DaliException e) {
73435       {
73436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73437       };
73438     } catch (...) {
73439       {
73440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73441       };
73442     }
73443   }
73444
73445   jresult = result;
73446   return jresult;
73447 }
73448
73449
73450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73451   float jresult ;
73452   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73453   float arg2 ;
73454   float arg3 ;
73455   float arg4 ;
73456   float arg5 ;
73457   Dali::Toolkit::ClampState *arg6 = 0 ;
73458   float result;
73459
73460   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73461   arg2 = (float)jarg2;
73462   arg3 = (float)jarg3;
73463   arg4 = (float)jarg4;
73464   arg5 = (float)jarg5;
73465   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73466   if (!arg6) {
73467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73468     return 0;
73469   }
73470   {
73471     try {
73472       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73473     } catch (std::out_of_range& e) {
73474       {
73475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73476       };
73477     } catch (std::exception& e) {
73478       {
73479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73480       };
73481     } catch (Dali::DaliException e) {
73482       {
73483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73484       };
73485     } catch (...) {
73486       {
73487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73488       };
73489     }
73490   }
73491
73492   jresult = result;
73493   return jresult;
73494 }
73495
73496
73497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73498   void * jresult ;
73499   Dali::Toolkit::DefaultRuler *result = 0 ;
73500
73501   {
73502     try {
73503       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73504     } catch (std::out_of_range& e) {
73505       {
73506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73507       };
73508     } catch (std::exception& e) {
73509       {
73510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73511       };
73512     } catch (Dali::DaliException e) {
73513       {
73514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73515       };
73516     } catch (...) {
73517       {
73518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73519       };
73520     }
73521   }
73522
73523   jresult = (void *)result;
73524   return jresult;
73525 }
73526
73527
73528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73529   float jresult ;
73530   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73531   float arg2 ;
73532   float arg3 ;
73533   float result;
73534
73535   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73536   arg2 = (float)jarg2;
73537   arg3 = (float)jarg3;
73538   {
73539     try {
73540       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73541     } catch (std::out_of_range& e) {
73542       {
73543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73544       };
73545     } catch (std::exception& e) {
73546       {
73547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73548       };
73549     } catch (Dali::DaliException e) {
73550       {
73551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73552       };
73553     } catch (...) {
73554       {
73555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73556       };
73557     }
73558   }
73559
73560   jresult = result;
73561   return jresult;
73562 }
73563
73564
73565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73566   float jresult ;
73567   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73568   unsigned int arg2 ;
73569   unsigned int *arg3 = 0 ;
73570   bool arg4 ;
73571   float result;
73572
73573   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73574   arg2 = (unsigned int)jarg2;
73575   arg3 = (unsigned int *)jarg3;
73576   arg4 = jarg4 ? true : false;
73577   {
73578     try {
73579       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73580     } catch (std::out_of_range& e) {
73581       {
73582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73583       };
73584     } catch (std::exception& e) {
73585       {
73586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73587       };
73588     } catch (Dali::DaliException e) {
73589       {
73590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73591       };
73592     } catch (...) {
73593       {
73594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73595       };
73596     }
73597   }
73598
73599   jresult = result;
73600   return jresult;
73601 }
73602
73603
73604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73605   unsigned int jresult ;
73606   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73607   float arg2 ;
73608   bool arg3 ;
73609   unsigned int result;
73610
73611   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73612   arg2 = (float)jarg2;
73613   arg3 = jarg3 ? true : false;
73614   {
73615     try {
73616       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73617     } catch (std::out_of_range& e) {
73618       {
73619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73620       };
73621     } catch (std::exception& e) {
73622       {
73623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73624       };
73625     } catch (Dali::DaliException e) {
73626       {
73627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73628       };
73629     } catch (...) {
73630       {
73631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73632       };
73633     }
73634   }
73635
73636   jresult = result;
73637   return jresult;
73638 }
73639
73640
73641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73642   unsigned int jresult ;
73643   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73644   unsigned int result;
73645
73646   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73647   {
73648     try {
73649       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73650     } catch (std::out_of_range& e) {
73651       {
73652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73653       };
73654     } catch (std::exception& e) {
73655       {
73656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73657       };
73658     } catch (Dali::DaliException e) {
73659       {
73660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73661       };
73662     } catch (...) {
73663       {
73664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73665       };
73666     }
73667   }
73668
73669   jresult = result;
73670   return jresult;
73671 }
73672
73673
73674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73675   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73676
73677   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73678   {
73679     try {
73680       delete arg1;
73681     } catch (std::out_of_range& e) {
73682       {
73683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73684       };
73685     } catch (std::exception& e) {
73686       {
73687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73688       };
73689     } catch (Dali::DaliException e) {
73690       {
73691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73692       };
73693     } catch (...) {
73694       {
73695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73696       };
73697     }
73698   }
73699
73700 }
73701
73702
73703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73704   void * jresult ;
73705   float arg1 ;
73706   Dali::Toolkit::FixedRuler *result = 0 ;
73707
73708   arg1 = (float)jarg1;
73709   {
73710     try {
73711       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73712     } catch (std::out_of_range& e) {
73713       {
73714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73715       };
73716     } catch (std::exception& e) {
73717       {
73718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73719       };
73720     } catch (Dali::DaliException e) {
73721       {
73722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73723       };
73724     } catch (...) {
73725       {
73726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73727       };
73728     }
73729   }
73730
73731   jresult = (void *)result;
73732   return jresult;
73733 }
73734
73735
73736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73737   void * jresult ;
73738   Dali::Toolkit::FixedRuler *result = 0 ;
73739
73740   {
73741     try {
73742       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73743     } catch (std::out_of_range& e) {
73744       {
73745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73746       };
73747     } catch (std::exception& e) {
73748       {
73749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73750       };
73751     } catch (Dali::DaliException e) {
73752       {
73753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73754       };
73755     } catch (...) {
73756       {
73757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73758       };
73759     }
73760   }
73761
73762   jresult = (void *)result;
73763   return jresult;
73764 }
73765
73766
73767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73768   float jresult ;
73769   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73770   float arg2 ;
73771   float arg3 ;
73772   float result;
73773
73774   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73775   arg2 = (float)jarg2;
73776   arg3 = (float)jarg3;
73777   {
73778     try {
73779       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73780     } catch (std::out_of_range& e) {
73781       {
73782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73783       };
73784     } catch (std::exception& e) {
73785       {
73786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73787       };
73788     } catch (Dali::DaliException e) {
73789       {
73790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73791       };
73792     } catch (...) {
73793       {
73794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73795       };
73796     }
73797   }
73798
73799   jresult = result;
73800   return jresult;
73801 }
73802
73803
73804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73805   float jresult ;
73806   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73807   unsigned int arg2 ;
73808   unsigned int *arg3 = 0 ;
73809   bool arg4 ;
73810   float result;
73811
73812   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73813   arg2 = (unsigned int)jarg2;
73814   arg3 = (unsigned int *)jarg3;
73815   arg4 = jarg4 ? true : false;
73816   {
73817     try {
73818       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73819     } catch (std::out_of_range& e) {
73820       {
73821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73822       };
73823     } catch (std::exception& e) {
73824       {
73825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73826       };
73827     } catch (Dali::DaliException e) {
73828       {
73829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73830       };
73831     } catch (...) {
73832       {
73833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73834       };
73835     }
73836   }
73837
73838   jresult = result;
73839   return jresult;
73840 }
73841
73842
73843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73844   unsigned int jresult ;
73845   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73846   float arg2 ;
73847   bool arg3 ;
73848   unsigned int result;
73849
73850   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73851   arg2 = (float)jarg2;
73852   arg3 = jarg3 ? true : false;
73853   {
73854     try {
73855       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73856     } catch (std::out_of_range& e) {
73857       {
73858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73859       };
73860     } catch (std::exception& e) {
73861       {
73862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73863       };
73864     } catch (Dali::DaliException e) {
73865       {
73866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73867       };
73868     } catch (...) {
73869       {
73870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73871       };
73872     }
73873   }
73874
73875   jresult = result;
73876   return jresult;
73877 }
73878
73879
73880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73881   unsigned int jresult ;
73882   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73883   unsigned int result;
73884
73885   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73886   {
73887     try {
73888       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73889     } catch (std::out_of_range& e) {
73890       {
73891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73892       };
73893     } catch (std::exception& e) {
73894       {
73895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73896       };
73897     } catch (Dali::DaliException e) {
73898       {
73899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73900       };
73901     } catch (...) {
73902       {
73903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73904       };
73905     }
73906   }
73907
73908   jresult = result;
73909   return jresult;
73910 }
73911
73912
73913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73914   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73915
73916   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73917   {
73918     try {
73919       delete arg1;
73920     } catch (std::out_of_range& e) {
73921       {
73922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73923       };
73924     } catch (std::exception& e) {
73925       {
73926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73927       };
73928     } catch (Dali::DaliException e) {
73929       {
73930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73931       };
73932     } catch (...) {
73933       {
73934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73935       };
73936     }
73937   }
73938
73939 }
73940
73941
73942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73943   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73944   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73945
73946   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73947   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73948   if (arg1) (arg1)->scale = *arg2;
73949 }
73950
73951
73952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73953   void * jresult ;
73954   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73955   Dali::Toolkit::ClampState2D *result = 0 ;
73956
73957   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73958   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73959   jresult = (void *)result;
73960   return jresult;
73961 }
73962
73963
73964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73965   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73966   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73967
73968   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73969   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73970   if (arg1) (arg1)->position = *arg2;
73971 }
73972
73973
73974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73975   void * jresult ;
73976   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73977   Dali::Toolkit::ClampState2D *result = 0 ;
73978
73979   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73980   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73981   jresult = (void *)result;
73982   return jresult;
73983 }
73984
73985
73986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73987   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73988   Dali::Toolkit::ClampState arg2 ;
73989
73990   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73991   arg2 = (Dali::Toolkit::ClampState)jarg2;
73992   if (arg1) (arg1)->rotation = arg2;
73993 }
73994
73995
73996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73997   int jresult ;
73998   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73999   Dali::Toolkit::ClampState result;
74000
74001   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74002   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
74003   jresult = (int)result;
74004   return jresult;
74005 }
74006
74007
74008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
74009   void * jresult ;
74010   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
74011
74012   {
74013     try {
74014       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
74015     } catch (std::out_of_range& e) {
74016       {
74017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74018       };
74019     } catch (std::exception& e) {
74020       {
74021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74022       };
74023     } catch (Dali::DaliException e) {
74024       {
74025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74026       };
74027     } catch (...) {
74028       {
74029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74030       };
74031     }
74032   }
74033
74034   jresult = (void *)result;
74035   return jresult;
74036 }
74037
74038
74039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
74040   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74041
74042   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74043   {
74044     try {
74045       delete arg1;
74046     } catch (std::out_of_range& e) {
74047       {
74048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74049       };
74050     } catch (std::exception& e) {
74051       {
74052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74053       };
74054     } catch (Dali::DaliException e) {
74055       {
74056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74057       };
74058     } catch (...) {
74059       {
74060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74061       };
74062     }
74063   }
74064
74065 }
74066
74067
74068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
74069   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74070   Dali::Toolkit::SnapType arg2 ;
74071
74072   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74073   arg2 = (Dali::Toolkit::SnapType)jarg2;
74074   if (arg1) (arg1)->type = arg2;
74075 }
74076
74077
74078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
74079   int jresult ;
74080   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74081   Dali::Toolkit::SnapType result;
74082
74083   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74084   result = (Dali::Toolkit::SnapType) ((arg1)->type);
74085   jresult = (int)result;
74086   return jresult;
74087 }
74088
74089
74090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
74091   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74092   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
74093
74094   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74095   arg2 = (Dali::Vector2 *)jarg2;
74096   if (arg1) (arg1)->position = *arg2;
74097 }
74098
74099
74100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
74101   void * jresult ;
74102   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74103   Dali::Vector2 *result = 0 ;
74104
74105   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74106   result = (Dali::Vector2 *)& ((arg1)->position);
74107   jresult = (void *)result;
74108   return jresult;
74109 }
74110
74111
74112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
74113   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74114   float arg2 ;
74115
74116   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74117   arg2 = (float)jarg2;
74118   if (arg1) (arg1)->duration = arg2;
74119 }
74120
74121
74122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
74123   float jresult ;
74124   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74125   float result;
74126
74127   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74128   result = (float) ((arg1)->duration);
74129   jresult = result;
74130   return jresult;
74131 }
74132
74133
74134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74135   void * jresult ;
74136   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74137
74138   {
74139     try {
74140       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74141     } catch (std::out_of_range& e) {
74142       {
74143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74144       };
74145     } catch (std::exception& e) {
74146       {
74147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74148       };
74149     } catch (Dali::DaliException e) {
74150       {
74151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74152       };
74153     } catch (...) {
74154       {
74155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74156       };
74157     }
74158   }
74159
74160   jresult = (void *)result;
74161   return jresult;
74162 }
74163
74164
74165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74166   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74167
74168   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74169   {
74170     try {
74171       delete arg1;
74172     } catch (std::out_of_range& e) {
74173       {
74174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74175       };
74176     } catch (std::exception& e) {
74177       {
74178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74179       };
74180     } catch (Dali::DaliException e) {
74181       {
74182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74183       };
74184     } catch (...) {
74185       {
74186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74187       };
74188     }
74189   }
74190
74191 }
74192
74193
74194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74195   int jresult ;
74196   int result;
74197
74198   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74199   jresult = (int)result;
74200   return jresult;
74201 }
74202
74203
74204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74205   int jresult ;
74206   int result;
74207
74208   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74209   jresult = (int)result;
74210   return jresult;
74211 }
74212
74213
74214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74215   int jresult ;
74216   int result;
74217
74218   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74219   jresult = (int)result;
74220   return jresult;
74221 }
74222
74223
74224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74225   int jresult ;
74226   int result;
74227
74228   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74229   jresult = (int)result;
74230   return jresult;
74231 }
74232
74233
74234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74235   int jresult ;
74236   int result;
74237
74238   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74239   jresult = (int)result;
74240   return jresult;
74241 }
74242
74243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74244   int jresult ;
74245   int result;
74246
74247   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74248   jresult = (int)result;
74249   return jresult;
74250 }
74251
74252
74253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74254   int jresult ;
74255   int result;
74256
74257   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74258   jresult = (int)result;
74259   return jresult;
74260 }
74261
74262
74263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74264   int jresult ;
74265   int result;
74266
74267   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74268   jresult = (int)result;
74269   return jresult;
74270 }
74271
74272
74273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74274   int jresult ;
74275   int result;
74276
74277   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74278   jresult = (int)result;
74279   return jresult;
74280 }
74281
74282
74283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74284   int jresult ;
74285   int result;
74286
74287   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74288   jresult = (int)result;
74289   return jresult;
74290 }
74291
74292
74293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74294   int jresult ;
74295   int result;
74296
74297   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74298   jresult = (int)result;
74299   return jresult;
74300 }
74301
74302
74303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74304   int jresult ;
74305   int result;
74306
74307   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74308   jresult = (int)result;
74309   return jresult;
74310 }
74311
74312
74313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74314   int jresult ;
74315   int result;
74316
74317   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74318   jresult = (int)result;
74319   return jresult;
74320 }
74321
74322
74323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74324   int jresult ;
74325   int result;
74326
74327   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74328   jresult = (int)result;
74329   return jresult;
74330 }
74331
74332
74333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74334   int jresult ;
74335   int result;
74336
74337   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74338   jresult = (int)result;
74339   return jresult;
74340 }
74341
74342
74343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74344   int jresult ;
74345   int result;
74346
74347   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74348   jresult = (int)result;
74349   return jresult;
74350 }
74351
74352
74353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74354   int jresult ;
74355   int result;
74356
74357   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74358   jresult = (int)result;
74359   return jresult;
74360 }
74361
74362
74363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74364   int jresult ;
74365   int result;
74366
74367   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74368   jresult = (int)result;
74369   return jresult;
74370 }
74371
74372
74373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74374   int jresult ;
74375   int result;
74376
74377   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74378   jresult = (int)result;
74379   return jresult;
74380 }
74381
74382
74383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74384   int jresult ;
74385   int result;
74386
74387   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74388   jresult = (int)result;
74389   return jresult;
74390 }
74391
74392
74393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74394   int jresult ;
74395   int result;
74396
74397   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74398   jresult = (int)result;
74399   return jresult;
74400 }
74401
74402
74403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74404   int jresult ;
74405   int result;
74406
74407   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74408   jresult = (int)result;
74409   return jresult;
74410 }
74411
74412
74413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74414   int jresult ;
74415   int result;
74416
74417   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74418   jresult = (int)result;
74419   return jresult;
74420 }
74421
74422
74423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74424   int jresult ;
74425   int result;
74426
74427   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74428   jresult = (int)result;
74429   return jresult;
74430 }
74431
74432
74433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74434   int jresult ;
74435   int result;
74436
74437   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74438   jresult = (int)result;
74439   return jresult;
74440 }
74441
74442
74443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74444   int jresult ;
74445   int result;
74446
74447   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74448   jresult = (int)result;
74449   return jresult;
74450 }
74451
74452
74453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74454   void * jresult ;
74455   Dali::Toolkit::ScrollView::Property *result = 0 ;
74456
74457   {
74458     try {
74459       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74460     } catch (std::out_of_range& e) {
74461       {
74462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74463       };
74464     } catch (std::exception& e) {
74465       {
74466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74467       };
74468     } catch (Dali::DaliException e) {
74469       {
74470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74471       };
74472     } catch (...) {
74473       {
74474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74475       };
74476     }
74477   }
74478
74479   jresult = (void *)result;
74480   return jresult;
74481 }
74482
74483
74484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74485   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74486
74487   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74488   {
74489     try {
74490       delete arg1;
74491     } catch (std::out_of_range& e) {
74492       {
74493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74494       };
74495     } catch (std::exception& e) {
74496       {
74497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74498       };
74499     } catch (Dali::DaliException e) {
74500       {
74501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74502       };
74503     } catch (...) {
74504       {
74505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74506       };
74507     }
74508   }
74509
74510 }
74511
74512
74513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74514   void * jresult ;
74515   Dali::Toolkit::ScrollView *result = 0 ;
74516
74517   {
74518     try {
74519       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74520     } catch (std::out_of_range& e) {
74521       {
74522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74523       };
74524     } catch (std::exception& e) {
74525       {
74526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74527       };
74528     } catch (Dali::DaliException e) {
74529       {
74530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74531       };
74532     } catch (...) {
74533       {
74534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74535       };
74536     }
74537   }
74538
74539   jresult = (void *)result;
74540   return jresult;
74541 }
74542
74543
74544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74545   void * jresult ;
74546   Dali::Toolkit::ScrollView *arg1 = 0 ;
74547   Dali::Toolkit::ScrollView *result = 0 ;
74548
74549   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74550   if (!arg1) {
74551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74552     return 0;
74553   }
74554   {
74555     try {
74556       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74557     } catch (std::out_of_range& e) {
74558       {
74559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74560       };
74561     } catch (std::exception& e) {
74562       {
74563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74564       };
74565     } catch (Dali::DaliException e) {
74566       {
74567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74568       };
74569     } catch (...) {
74570       {
74571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74572       };
74573     }
74574   }
74575
74576   jresult = (void *)result;
74577   return jresult;
74578 }
74579
74580
74581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74582   void * jresult ;
74583   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74584   Dali::Toolkit::ScrollView *arg2 = 0 ;
74585   Dali::Toolkit::ScrollView *result = 0 ;
74586
74587   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74588   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74589   if (!arg2) {
74590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74591     return 0;
74592   }
74593   {
74594     try {
74595       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74596     } catch (std::out_of_range& e) {
74597       {
74598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74599       };
74600     } catch (std::exception& e) {
74601       {
74602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74603       };
74604     } catch (Dali::DaliException e) {
74605       {
74606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74607       };
74608     } catch (...) {
74609       {
74610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74611       };
74612     }
74613   }
74614
74615   jresult = (void *)result;
74616   return jresult;
74617 }
74618
74619
74620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74621   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74622
74623   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74624   {
74625     try {
74626       delete arg1;
74627     } catch (std::out_of_range& e) {
74628       {
74629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74630       };
74631     } catch (std::exception& e) {
74632       {
74633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74634       };
74635     } catch (Dali::DaliException e) {
74636       {
74637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74638       };
74639     } catch (...) {
74640       {
74641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74642       };
74643     }
74644   }
74645
74646 }
74647
74648
74649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74650   void * jresult ;
74651   Dali::Toolkit::ScrollView result;
74652
74653   {
74654     try {
74655       result = Dali::Toolkit::ScrollView::New();
74656     } catch (std::out_of_range& e) {
74657       {
74658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74659       };
74660     } catch (std::exception& e) {
74661       {
74662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74663       };
74664     } catch (Dali::DaliException e) {
74665       {
74666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74667       };
74668     } catch (...) {
74669       {
74670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74671       };
74672     }
74673   }
74674
74675   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74676   return jresult;
74677 }
74678
74679
74680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74681   void * jresult ;
74682   Dali::BaseHandle arg1 ;
74683   Dali::BaseHandle *argp1 ;
74684   Dali::Toolkit::ScrollView result;
74685
74686   argp1 = (Dali::BaseHandle *)jarg1;
74687   if (!argp1) {
74688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74689     return 0;
74690   }
74691   arg1 = *argp1;
74692   {
74693     try {
74694       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74695     } catch (std::out_of_range& e) {
74696       {
74697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74698       };
74699     } catch (std::exception& e) {
74700       {
74701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74702       };
74703     } catch (Dali::DaliException e) {
74704       {
74705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74706       };
74707     } catch (...) {
74708       {
74709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74710       };
74711     }
74712   }
74713
74714   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74715   return jresult;
74716 }
74717
74718
74719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74720   void * jresult ;
74721   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74722   Dali::AlphaFunction result;
74723
74724   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74725   {
74726     try {
74727       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74728     } catch (std::out_of_range& e) {
74729       {
74730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74731       };
74732     } catch (std::exception& e) {
74733       {
74734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74735       };
74736     } catch (Dali::DaliException e) {
74737       {
74738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74739       };
74740     } catch (...) {
74741       {
74742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74743       };
74744     }
74745   }
74746
74747   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74748   return jresult;
74749 }
74750
74751
74752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74753   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74754   Dali::AlphaFunction arg2 ;
74755   Dali::AlphaFunction *argp2 ;
74756
74757   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74758   argp2 = (Dali::AlphaFunction *)jarg2;
74759   if (!argp2) {
74760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74761     return ;
74762   }
74763   arg2 = *argp2;
74764   {
74765     try {
74766       (arg1)->SetScrollSnapAlphaFunction(arg2);
74767     } catch (std::out_of_range& e) {
74768       {
74769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74770       };
74771     } catch (std::exception& e) {
74772       {
74773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74774       };
74775     } catch (Dali::DaliException e) {
74776       {
74777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74778       };
74779     } catch (...) {
74780       {
74781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74782       };
74783     }
74784   }
74785
74786 }
74787
74788
74789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74790   void * jresult ;
74791   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74792   Dali::AlphaFunction result;
74793
74794   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74795   {
74796     try {
74797       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74798     } catch (std::out_of_range& e) {
74799       {
74800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74801       };
74802     } catch (std::exception& e) {
74803       {
74804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74805       };
74806     } catch (Dali::DaliException e) {
74807       {
74808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74809       };
74810     } catch (...) {
74811       {
74812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74813       };
74814     }
74815   }
74816
74817   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74818   return jresult;
74819 }
74820
74821
74822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74823   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74824   Dali::AlphaFunction arg2 ;
74825   Dali::AlphaFunction *argp2 ;
74826
74827   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74828   argp2 = (Dali::AlphaFunction *)jarg2;
74829   if (!argp2) {
74830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74831     return ;
74832   }
74833   arg2 = *argp2;
74834   {
74835     try {
74836       (arg1)->SetScrollFlickAlphaFunction(arg2);
74837     } catch (std::out_of_range& e) {
74838       {
74839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74840       };
74841     } catch (std::exception& e) {
74842       {
74843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74844       };
74845     } catch (Dali::DaliException e) {
74846       {
74847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74848       };
74849     } catch (...) {
74850       {
74851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74852       };
74853     }
74854   }
74855
74856 }
74857
74858
74859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74860   float jresult ;
74861   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74862   float result;
74863
74864   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74865   {
74866     try {
74867       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74868     } catch (std::out_of_range& e) {
74869       {
74870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74871       };
74872     } catch (std::exception& e) {
74873       {
74874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74875       };
74876     } catch (Dali::DaliException e) {
74877       {
74878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74879       };
74880     } catch (...) {
74881       {
74882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74883       };
74884     }
74885   }
74886
74887   jresult = result;
74888   return jresult;
74889 }
74890
74891
74892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74893   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74894   float arg2 ;
74895
74896   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74897   arg2 = (float)jarg2;
74898   {
74899     try {
74900       (arg1)->SetScrollSnapDuration(arg2);
74901     } catch (std::out_of_range& e) {
74902       {
74903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74904       };
74905     } catch (std::exception& e) {
74906       {
74907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74908       };
74909     } catch (Dali::DaliException e) {
74910       {
74911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74912       };
74913     } catch (...) {
74914       {
74915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74916       };
74917     }
74918   }
74919
74920 }
74921
74922
74923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74924   float jresult ;
74925   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74926   float result;
74927
74928   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74929   {
74930     try {
74931       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74932     } catch (std::out_of_range& e) {
74933       {
74934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74935       };
74936     } catch (std::exception& e) {
74937       {
74938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74939       };
74940     } catch (Dali::DaliException e) {
74941       {
74942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74943       };
74944     } catch (...) {
74945       {
74946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74947       };
74948     }
74949   }
74950
74951   jresult = result;
74952   return jresult;
74953 }
74954
74955
74956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74957   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74958   float arg2 ;
74959
74960   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74961   arg2 = (float)jarg2;
74962   {
74963     try {
74964       (arg1)->SetScrollFlickDuration(arg2);
74965     } catch (std::out_of_range& e) {
74966       {
74967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74968       };
74969     } catch (std::exception& e) {
74970       {
74971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74972       };
74973     } catch (Dali::DaliException e) {
74974       {
74975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74976       };
74977     } catch (...) {
74978       {
74979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74980       };
74981     }
74982   }
74983
74984 }
74985
74986
74987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74988   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74989   Dali::Toolkit::RulerPtr arg2 ;
74990   Dali::Toolkit::RulerPtr *argp2 ;
74991
74992   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74993   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74994   if (!argp2) {
74995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74996     return ;
74997   }
74998   arg2 = *argp2;
74999   {
75000     try {
75001       (arg1)->SetRulerX(arg2);
75002     } catch (std::out_of_range& e) {
75003       {
75004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75005       };
75006     } catch (std::exception& e) {
75007       {
75008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75009       };
75010     } catch (Dali::DaliException e) {
75011       {
75012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75013       };
75014     } catch (...) {
75015       {
75016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75017       };
75018     }
75019   }
75020
75021 }
75022
75023
75024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
75025   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75026   Dali::Toolkit::RulerPtr arg2 ;
75027   Dali::Toolkit::RulerPtr *argp2 ;
75028
75029   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75030   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75031   if (!argp2) {
75032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75033     return ;
75034   }
75035   arg2 = *argp2;
75036   {
75037     try {
75038       (arg1)->SetRulerY(arg2);
75039     } catch (std::out_of_range& e) {
75040       {
75041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75042       };
75043     } catch (std::exception& e) {
75044       {
75045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75046       };
75047     } catch (Dali::DaliException e) {
75048       {
75049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75050       };
75051     } catch (...) {
75052       {
75053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75054       };
75055     }
75056   }
75057
75058 }
75059
75060
75061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
75062   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75063   bool arg2 ;
75064
75065   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75066   arg2 = jarg2 ? true : false;
75067   {
75068     try {
75069       (arg1)->SetScrollSensitive(arg2);
75070     } catch (std::out_of_range& e) {
75071       {
75072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75073       };
75074     } catch (std::exception& e) {
75075       {
75076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75077       };
75078     } catch (Dali::DaliException e) {
75079       {
75080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75081       };
75082     } catch (...) {
75083       {
75084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75085       };
75086     }
75087   }
75088
75089 }
75090
75091
75092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
75093   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75094   float arg2 ;
75095   float arg3 ;
75096
75097   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75098   arg2 = (float)jarg2;
75099   arg3 = (float)jarg3;
75100   {
75101     try {
75102       (arg1)->SetMaxOvershoot(arg2,arg3);
75103     } catch (std::out_of_range& e) {
75104       {
75105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75106       };
75107     } catch (std::exception& e) {
75108       {
75109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75110       };
75111     } catch (Dali::DaliException e) {
75112       {
75113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75114       };
75115     } catch (...) {
75116       {
75117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75118       };
75119     }
75120   }
75121
75122 }
75123
75124
75125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
75126   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75127   Dali::AlphaFunction arg2 ;
75128   Dali::AlphaFunction *argp2 ;
75129
75130   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75131   argp2 = (Dali::AlphaFunction *)jarg2;
75132   if (!argp2) {
75133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75134     return ;
75135   }
75136   arg2 = *argp2;
75137   {
75138     try {
75139       (arg1)->SetSnapOvershootAlphaFunction(arg2);
75140     } catch (std::out_of_range& e) {
75141       {
75142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75143       };
75144     } catch (std::exception& e) {
75145       {
75146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75147       };
75148     } catch (Dali::DaliException e) {
75149       {
75150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75151       };
75152     } catch (...) {
75153       {
75154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75155       };
75156     }
75157   }
75158
75159 }
75160
75161
75162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75163   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75164   float arg2 ;
75165
75166   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75167   arg2 = (float)jarg2;
75168   {
75169     try {
75170       (arg1)->SetSnapOvershootDuration(arg2);
75171     } catch (std::out_of_range& e) {
75172       {
75173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75174       };
75175     } catch (std::exception& e) {
75176       {
75177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75178       };
75179     } catch (Dali::DaliException e) {
75180       {
75181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75182       };
75183     } catch (...) {
75184       {
75185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75186       };
75187     }
75188   }
75189
75190 }
75191
75192
75193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75194   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75195   bool arg2 ;
75196
75197   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75198   arg2 = jarg2 ? true : false;
75199   {
75200     try {
75201       (arg1)->SetActorAutoSnap(arg2);
75202     } catch (std::out_of_range& e) {
75203       {
75204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75205       };
75206     } catch (std::exception& e) {
75207       {
75208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75209       };
75210     } catch (Dali::DaliException e) {
75211       {
75212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75213       };
75214     } catch (...) {
75215       {
75216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75217       };
75218     }
75219   }
75220
75221 }
75222
75223
75224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75225   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75226   bool arg2 ;
75227
75228   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75229   arg2 = jarg2 ? true : false;
75230   {
75231     try {
75232       (arg1)->SetWrapMode(arg2);
75233     } catch (std::out_of_range& e) {
75234       {
75235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75236       };
75237     } catch (std::exception& e) {
75238       {
75239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75240       };
75241     } catch (Dali::DaliException e) {
75242       {
75243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75244       };
75245     } catch (...) {
75246       {
75247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75248       };
75249     }
75250   }
75251
75252 }
75253
75254
75255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75256   int jresult ;
75257   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75258   int result;
75259
75260   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75261   {
75262     try {
75263       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75264     } catch (std::out_of_range& e) {
75265       {
75266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75267       };
75268     } catch (std::exception& e) {
75269       {
75270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75271       };
75272     } catch (Dali::DaliException e) {
75273       {
75274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75275       };
75276     } catch (...) {
75277       {
75278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75279       };
75280     }
75281   }
75282
75283   jresult = result;
75284   return jresult;
75285 }
75286
75287
75288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75289   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75290   int arg2 ;
75291
75292   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75293   arg2 = (int)jarg2;
75294   {
75295     try {
75296       (arg1)->SetScrollUpdateDistance(arg2);
75297     } catch (std::out_of_range& e) {
75298       {
75299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75300       };
75301     } catch (std::exception& e) {
75302       {
75303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75304       };
75305     } catch (Dali::DaliException e) {
75306       {
75307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75308       };
75309     } catch (...) {
75310       {
75311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75312       };
75313     }
75314   }
75315
75316 }
75317
75318
75319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75320   unsigned int jresult ;
75321   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75322   bool result;
75323
75324   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75325   {
75326     try {
75327       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75328     } catch (std::out_of_range& e) {
75329       {
75330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75331       };
75332     } catch (std::exception& e) {
75333       {
75334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75335       };
75336     } catch (Dali::DaliException e) {
75337       {
75338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75339       };
75340     } catch (...) {
75341       {
75342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75343       };
75344     }
75345   }
75346
75347   jresult = result;
75348   return jresult;
75349 }
75350
75351
75352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75353   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75354   bool arg2 ;
75355
75356   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75357   arg2 = jarg2 ? true : false;
75358   {
75359     try {
75360       (arg1)->SetAxisAutoLock(arg2);
75361     } catch (std::out_of_range& e) {
75362       {
75363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75364       };
75365     } catch (std::exception& e) {
75366       {
75367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75368       };
75369     } catch (Dali::DaliException e) {
75370       {
75371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75372       };
75373     } catch (...) {
75374       {
75375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75376       };
75377     }
75378   }
75379
75380 }
75381
75382
75383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75384   float jresult ;
75385   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75386   float result;
75387
75388   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75389   {
75390     try {
75391       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75392     } catch (std::out_of_range& e) {
75393       {
75394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75395       };
75396     } catch (std::exception& e) {
75397       {
75398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75399       };
75400     } catch (Dali::DaliException e) {
75401       {
75402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75403       };
75404     } catch (...) {
75405       {
75406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75407       };
75408     }
75409   }
75410
75411   jresult = result;
75412   return jresult;
75413 }
75414
75415
75416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75417   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75418   float arg2 ;
75419
75420   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75421   arg2 = (float)jarg2;
75422   {
75423     try {
75424       (arg1)->SetAxisAutoLockGradient(arg2);
75425     } catch (std::out_of_range& e) {
75426       {
75427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75428       };
75429     } catch (std::exception& e) {
75430       {
75431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75432       };
75433     } catch (Dali::DaliException e) {
75434       {
75435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75436       };
75437     } catch (...) {
75438       {
75439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75440       };
75441     }
75442   }
75443
75444 }
75445
75446
75447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75448   float jresult ;
75449   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75450   float result;
75451
75452   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75453   {
75454     try {
75455       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75456     } catch (std::out_of_range& e) {
75457       {
75458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75459       };
75460     } catch (std::exception& e) {
75461       {
75462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75463       };
75464     } catch (Dali::DaliException e) {
75465       {
75466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75467       };
75468     } catch (...) {
75469       {
75470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75471       };
75472     }
75473   }
75474
75475   jresult = result;
75476   return jresult;
75477 }
75478
75479
75480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75481   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75482   float arg2 ;
75483
75484   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75485   arg2 = (float)jarg2;
75486   {
75487     try {
75488       (arg1)->SetFrictionCoefficient(arg2);
75489     } catch (std::out_of_range& e) {
75490       {
75491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75492       };
75493     } catch (std::exception& e) {
75494       {
75495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75496       };
75497     } catch (Dali::DaliException e) {
75498       {
75499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75500       };
75501     } catch (...) {
75502       {
75503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75504       };
75505     }
75506   }
75507
75508 }
75509
75510
75511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75512   float jresult ;
75513   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75514   float result;
75515
75516   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75517   {
75518     try {
75519       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75520     } catch (std::out_of_range& e) {
75521       {
75522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75523       };
75524     } catch (std::exception& e) {
75525       {
75526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75527       };
75528     } catch (Dali::DaliException e) {
75529       {
75530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75531       };
75532     } catch (...) {
75533       {
75534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75535       };
75536     }
75537   }
75538
75539   jresult = result;
75540   return jresult;
75541 }
75542
75543
75544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75545   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75546   float arg2 ;
75547
75548   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75549   arg2 = (float)jarg2;
75550   {
75551     try {
75552       (arg1)->SetFlickSpeedCoefficient(arg2);
75553     } catch (std::out_of_range& e) {
75554       {
75555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75556       };
75557     } catch (std::exception& e) {
75558       {
75559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75560       };
75561     } catch (Dali::DaliException e) {
75562       {
75563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75564       };
75565     } catch (...) {
75566       {
75567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75568       };
75569     }
75570   }
75571
75572 }
75573
75574
75575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75576   void * jresult ;
75577   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75578   Dali::Vector2 result;
75579
75580   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75581   {
75582     try {
75583       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75584     } catch (std::out_of_range& e) {
75585       {
75586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75587       };
75588     } catch (std::exception& e) {
75589       {
75590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75591       };
75592     } catch (Dali::DaliException e) {
75593       {
75594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75595       };
75596     } catch (...) {
75597       {
75598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75599       };
75600     }
75601   }
75602
75603   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75604   return jresult;
75605 }
75606
75607
75608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75609   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75610   Dali::Vector2 *arg2 = 0 ;
75611
75612   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75613   arg2 = (Dali::Vector2 *)jarg2;
75614   if (!arg2) {
75615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75616     return ;
75617   }
75618   {
75619     try {
75620       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75621     } catch (std::out_of_range& e) {
75622       {
75623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75624       };
75625     } catch (std::exception& e) {
75626       {
75627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75628       };
75629     } catch (Dali::DaliException e) {
75630       {
75631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75632       };
75633     } catch (...) {
75634       {
75635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75636       };
75637     }
75638   }
75639
75640 }
75641
75642
75643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75644   float jresult ;
75645   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75646   float result;
75647
75648   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75649   {
75650     try {
75651       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75652     } catch (std::out_of_range& e) {
75653       {
75654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75655       };
75656     } catch (std::exception& e) {
75657       {
75658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75659       };
75660     } catch (Dali::DaliException e) {
75661       {
75662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75663       };
75664     } catch (...) {
75665       {
75666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75667       };
75668     }
75669   }
75670
75671   jresult = result;
75672   return jresult;
75673 }
75674
75675
75676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75677   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75678   float arg2 ;
75679
75680   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75681   arg2 = (float)jarg2;
75682   {
75683     try {
75684       (arg1)->SetMinimumSpeedForFlick(arg2);
75685     } catch (std::out_of_range& e) {
75686       {
75687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75688       };
75689     } catch (std::exception& e) {
75690       {
75691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75692       };
75693     } catch (Dali::DaliException e) {
75694       {
75695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75696       };
75697     } catch (...) {
75698       {
75699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75700       };
75701     }
75702   }
75703
75704 }
75705
75706
75707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75708   float jresult ;
75709   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75710   float result;
75711
75712   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75713   {
75714     try {
75715       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75716     } catch (std::out_of_range& e) {
75717       {
75718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75719       };
75720     } catch (std::exception& e) {
75721       {
75722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75723       };
75724     } catch (Dali::DaliException e) {
75725       {
75726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75727       };
75728     } catch (...) {
75729       {
75730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75731       };
75732     }
75733   }
75734
75735   jresult = result;
75736   return jresult;
75737 }
75738
75739
75740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75741   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75742   float arg2 ;
75743
75744   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75745   arg2 = (float)jarg2;
75746   {
75747     try {
75748       (arg1)->SetMaxFlickSpeed(arg2);
75749     } catch (std::out_of_range& e) {
75750       {
75751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75752       };
75753     } catch (std::exception& e) {
75754       {
75755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75756       };
75757     } catch (Dali::DaliException e) {
75758       {
75759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75760       };
75761     } catch (...) {
75762       {
75763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75764       };
75765     }
75766   }
75767
75768 }
75769
75770
75771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75772   void * jresult ;
75773   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75774   Dali::Vector2 result;
75775
75776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75777   {
75778     try {
75779       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75780     } catch (std::out_of_range& e) {
75781       {
75782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75783       };
75784     } catch (std::exception& e) {
75785       {
75786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75787       };
75788     } catch (Dali::DaliException e) {
75789       {
75790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75791       };
75792     } catch (...) {
75793       {
75794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75795       };
75796     }
75797   }
75798
75799   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75800   return jresult;
75801 }
75802
75803
75804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75805   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75806   Dali::Vector2 arg2 ;
75807   Dali::Vector2 *argp2 ;
75808
75809   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75810   argp2 = (Dali::Vector2 *)jarg2;
75811   if (!argp2) {
75812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75813     return ;
75814   }
75815   arg2 = *argp2;
75816   {
75817     try {
75818       (arg1)->SetWheelScrollDistanceStep(arg2);
75819     } catch (std::out_of_range& e) {
75820       {
75821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75822       };
75823     } catch (std::exception& e) {
75824       {
75825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75826       };
75827     } catch (Dali::DaliException e) {
75828       {
75829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75830       };
75831     } catch (...) {
75832       {
75833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75834       };
75835     }
75836   }
75837
75838 }
75839
75840
75841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75842   void * jresult ;
75843   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75844   Dali::Vector2 result;
75845
75846   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75847   {
75848     try {
75849       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75850     } catch (std::out_of_range& e) {
75851       {
75852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75853       };
75854     } catch (std::exception& e) {
75855       {
75856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75857       };
75858     } catch (Dali::DaliException e) {
75859       {
75860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75861       };
75862     } catch (...) {
75863       {
75864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75865       };
75866     }
75867   }
75868
75869   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75870   return jresult;
75871 }
75872
75873
75874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75875   unsigned int jresult ;
75876   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75877   unsigned int result;
75878
75879   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75880   {
75881     try {
75882       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75883     } catch (std::out_of_range& e) {
75884       {
75885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75886       };
75887     } catch (std::exception& e) {
75888       {
75889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75890       };
75891     } catch (Dali::DaliException e) {
75892       {
75893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75894       };
75895     } catch (...) {
75896       {
75897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75898       };
75899     }
75900   }
75901
75902   jresult = result;
75903   return jresult;
75904 }
75905
75906
75907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75908   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75909   Dali::Vector2 *arg2 = 0 ;
75910
75911   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75912   arg2 = (Dali::Vector2 *)jarg2;
75913   if (!arg2) {
75914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75915     return ;
75916   }
75917   {
75918     try {
75919       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75920     } catch (std::out_of_range& e) {
75921       {
75922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75923       };
75924     } catch (std::exception& e) {
75925       {
75926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75927       };
75928     } catch (Dali::DaliException e) {
75929       {
75930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75931       };
75932     } catch (...) {
75933       {
75934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75935       };
75936     }
75937   }
75938
75939 }
75940
75941
75942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75943   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75944   Dali::Vector2 *arg2 = 0 ;
75945   float arg3 ;
75946
75947   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75948   arg2 = (Dali::Vector2 *)jarg2;
75949   if (!arg2) {
75950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75951     return ;
75952   }
75953   arg3 = (float)jarg3;
75954   {
75955     try {
75956       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75957     } catch (std::out_of_range& e) {
75958       {
75959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75960       };
75961     } catch (std::exception& e) {
75962       {
75963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75964       };
75965     } catch (Dali::DaliException e) {
75966       {
75967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75968       };
75969     } catch (...) {
75970       {
75971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75972       };
75973     }
75974   }
75975
75976 }
75977
75978
75979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75980   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75981   Dali::Vector2 *arg2 = 0 ;
75982   float arg3 ;
75983   Dali::AlphaFunction arg4 ;
75984   Dali::AlphaFunction *argp4 ;
75985
75986   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75987   arg2 = (Dali::Vector2 *)jarg2;
75988   if (!arg2) {
75989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75990     return ;
75991   }
75992   arg3 = (float)jarg3;
75993   argp4 = (Dali::AlphaFunction *)jarg4;
75994   if (!argp4) {
75995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75996     return ;
75997   }
75998   arg4 = *argp4;
75999   {
76000     try {
76001       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
76002     } catch (std::out_of_range& e) {
76003       {
76004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76005       };
76006     } catch (std::exception& e) {
76007       {
76008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76009       };
76010     } catch (Dali::DaliException e) {
76011       {
76012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76013       };
76014     } catch (...) {
76015       {
76016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76017       };
76018     }
76019   }
76020
76021 }
76022
76023
76024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
76025   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76026   Dali::Vector2 *arg2 = 0 ;
76027   float arg3 ;
76028   Dali::Toolkit::DirectionBias arg4 ;
76029   Dali::Toolkit::DirectionBias arg5 ;
76030
76031   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76032   arg2 = (Dali::Vector2 *)jarg2;
76033   if (!arg2) {
76034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76035     return ;
76036   }
76037   arg3 = (float)jarg3;
76038   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76039   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76040   {
76041     try {
76042       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
76043     } catch (std::out_of_range& e) {
76044       {
76045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76046       };
76047     } catch (std::exception& e) {
76048       {
76049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76050       };
76051     } catch (Dali::DaliException e) {
76052       {
76053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76054       };
76055     } catch (...) {
76056       {
76057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76058       };
76059     }
76060   }
76061
76062 }
76063
76064
76065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
76066   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76067   Dali::Vector2 *arg2 = 0 ;
76068   float arg3 ;
76069   Dali::AlphaFunction arg4 ;
76070   Dali::Toolkit::DirectionBias arg5 ;
76071   Dali::Toolkit::DirectionBias arg6 ;
76072   Dali::AlphaFunction *argp4 ;
76073
76074   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76075   arg2 = (Dali::Vector2 *)jarg2;
76076   if (!arg2) {
76077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76078     return ;
76079   }
76080   arg3 = (float)jarg3;
76081   argp4 = (Dali::AlphaFunction *)jarg4;
76082   if (!argp4) {
76083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76084     return ;
76085   }
76086   arg4 = *argp4;
76087   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76088   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
76089   {
76090     try {
76091       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
76092     } catch (std::out_of_range& e) {
76093       {
76094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76095       };
76096     } catch (std::exception& e) {
76097       {
76098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76099       };
76100     } catch (Dali::DaliException e) {
76101       {
76102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76103       };
76104     } catch (...) {
76105       {
76106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76107       };
76108     }
76109   }
76110
76111 }
76112
76113
76114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
76115   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76116   unsigned int arg2 ;
76117
76118   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76119   arg2 = (unsigned int)jarg2;
76120   {
76121     try {
76122       (arg1)->ScrollTo(arg2);
76123     } catch (std::out_of_range& e) {
76124       {
76125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76126       };
76127     } catch (std::exception& e) {
76128       {
76129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76130       };
76131     } catch (Dali::DaliException e) {
76132       {
76133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76134       };
76135     } catch (...) {
76136       {
76137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76138       };
76139     }
76140   }
76141
76142 }
76143
76144
76145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
76146   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76147   unsigned int arg2 ;
76148   float arg3 ;
76149
76150   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76151   arg2 = (unsigned int)jarg2;
76152   arg3 = (float)jarg3;
76153   {
76154     try {
76155       (arg1)->ScrollTo(arg2,arg3);
76156     } catch (std::out_of_range& e) {
76157       {
76158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76159       };
76160     } catch (std::exception& e) {
76161       {
76162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76163       };
76164     } catch (Dali::DaliException e) {
76165       {
76166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76167       };
76168     } catch (...) {
76169       {
76170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76171       };
76172     }
76173   }
76174
76175 }
76176
76177
76178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76179   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76180   unsigned int arg2 ;
76181   float arg3 ;
76182   Dali::Toolkit::DirectionBias arg4 ;
76183
76184   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76185   arg2 = (unsigned int)jarg2;
76186   arg3 = (float)jarg3;
76187   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76188   {
76189     try {
76190       (arg1)->ScrollTo(arg2,arg3,arg4);
76191     } catch (std::out_of_range& e) {
76192       {
76193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76194       };
76195     } catch (std::exception& e) {
76196       {
76197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76198       };
76199     } catch (Dali::DaliException e) {
76200       {
76201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76202       };
76203     } catch (...) {
76204       {
76205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76206       };
76207     }
76208   }
76209
76210 }
76211
76212
76213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76214   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76215   Dali::Actor *arg2 = 0 ;
76216
76217   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76218   arg2 = (Dali::Actor *)jarg2;
76219   if (!arg2) {
76220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76221     return ;
76222   }
76223   {
76224     try {
76225       (arg1)->ScrollTo(*arg2);
76226     } catch (std::out_of_range& e) {
76227       {
76228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76229       };
76230     } catch (std::exception& e) {
76231       {
76232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76233       };
76234     } catch (Dali::DaliException e) {
76235       {
76236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76237       };
76238     } catch (...) {
76239       {
76240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76241       };
76242     }
76243   }
76244
76245 }
76246
76247
76248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76249   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76250   Dali::Actor *arg2 = 0 ;
76251   float arg3 ;
76252
76253   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76254   arg2 = (Dali::Actor *)jarg2;
76255   if (!arg2) {
76256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76257     return ;
76258   }
76259   arg3 = (float)jarg3;
76260   {
76261     try {
76262       (arg1)->ScrollTo(*arg2,arg3);
76263     } catch (std::out_of_range& e) {
76264       {
76265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76266       };
76267     } catch (std::exception& e) {
76268       {
76269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76270       };
76271     } catch (Dali::DaliException e) {
76272       {
76273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76274       };
76275     } catch (...) {
76276       {
76277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76278       };
76279     }
76280   }
76281
76282 }
76283
76284
76285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76286   unsigned int jresult ;
76287   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76288   bool result;
76289
76290   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76291   {
76292     try {
76293       result = (bool)(arg1)->ScrollToSnapPoint();
76294     } catch (std::out_of_range& e) {
76295       {
76296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76297       };
76298     } catch (std::exception& e) {
76299       {
76300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76301       };
76302     } catch (Dali::DaliException e) {
76303       {
76304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76305       };
76306     } catch (...) {
76307       {
76308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76309       };
76310     }
76311   }
76312
76313   jresult = result;
76314   return jresult;
76315 }
76316
76317
76318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76319   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76320   Dali::Constraint arg2 ;
76321   Dali::Constraint *argp2 ;
76322
76323   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76324   argp2 = (Dali::Constraint *)jarg2;
76325   if (!argp2) {
76326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76327     return ;
76328   }
76329   arg2 = *argp2;
76330   {
76331     try {
76332       (arg1)->ApplyConstraintToChildren(arg2);
76333     } catch (std::out_of_range& e) {
76334       {
76335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76336       };
76337     } catch (std::exception& e) {
76338       {
76339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76340       };
76341     } catch (Dali::DaliException e) {
76342       {
76343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76344       };
76345     } catch (...) {
76346       {
76347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76348       };
76349     }
76350   }
76351
76352 }
76353
76354
76355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76356   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76357
76358   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76359   {
76360     try {
76361       (arg1)->RemoveConstraintsFromChildren();
76362     } catch (std::out_of_range& e) {
76363       {
76364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76365       };
76366     } catch (std::exception& e) {
76367       {
76368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76369       };
76370     } catch (Dali::DaliException e) {
76371       {
76372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76373       };
76374     } catch (...) {
76375       {
76376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76377       };
76378     }
76379   }
76380
76381 }
76382
76383
76384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76385   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76386   Dali::Toolkit::ScrollViewEffect arg2 ;
76387   Dali::Toolkit::ScrollViewEffect *argp2 ;
76388
76389   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76390   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76391   if (!argp2) {
76392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76393     return ;
76394   }
76395   arg2 = *argp2;
76396   {
76397     try {
76398       (arg1)->ApplyEffect(arg2);
76399     } catch (std::out_of_range& e) {
76400       {
76401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76402       };
76403     } catch (std::exception& e) {
76404       {
76405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76406       };
76407     } catch (Dali::DaliException e) {
76408       {
76409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76410       };
76411     } catch (...) {
76412       {
76413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76414       };
76415     }
76416   }
76417
76418 }
76419
76420
76421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76422   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76423   Dali::Toolkit::ScrollViewEffect arg2 ;
76424   Dali::Toolkit::ScrollViewEffect *argp2 ;
76425
76426   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76427   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76428   if (!argp2) {
76429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76430     return ;
76431   }
76432   arg2 = *argp2;
76433   {
76434     try {
76435       (arg1)->RemoveEffect(arg2);
76436     } catch (std::out_of_range& e) {
76437       {
76438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76439       };
76440     } catch (std::exception& e) {
76441       {
76442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76443       };
76444     } catch (Dali::DaliException e) {
76445       {
76446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76447       };
76448     } catch (...) {
76449       {
76450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76451       };
76452     }
76453   }
76454
76455 }
76456
76457
76458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76459   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76460
76461   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76462   {
76463     try {
76464       (arg1)->RemoveAllEffects();
76465     } catch (std::out_of_range& e) {
76466       {
76467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76468       };
76469     } catch (std::exception& e) {
76470       {
76471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76472       };
76473     } catch (Dali::DaliException e) {
76474       {
76475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76476       };
76477     } catch (...) {
76478       {
76479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76480       };
76481     }
76482   }
76483
76484 }
76485
76486
76487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76488   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76489   Dali::Actor arg2 ;
76490   Dali::Actor *argp2 ;
76491
76492   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76493   argp2 = (Dali::Actor *)jarg2;
76494   if (!argp2) {
76495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76496     return ;
76497   }
76498   arg2 = *argp2;
76499   {
76500     try {
76501       (arg1)->BindActor(arg2);
76502     } catch (std::out_of_range& e) {
76503       {
76504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76505       };
76506     } catch (std::exception& e) {
76507       {
76508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76509       };
76510     } catch (Dali::DaliException e) {
76511       {
76512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76513       };
76514     } catch (...) {
76515       {
76516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76517       };
76518     }
76519   }
76520
76521 }
76522
76523
76524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76525   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76526   Dali::Actor arg2 ;
76527   Dali::Actor *argp2 ;
76528
76529   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76530   argp2 = (Dali::Actor *)jarg2;
76531   if (!argp2) {
76532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76533     return ;
76534   }
76535   arg2 = *argp2;
76536   {
76537     try {
76538       (arg1)->UnbindActor(arg2);
76539     } catch (std::out_of_range& e) {
76540       {
76541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76542       };
76543     } catch (std::exception& e) {
76544       {
76545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76546       };
76547     } catch (Dali::DaliException e) {
76548       {
76549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76550       };
76551     } catch (...) {
76552       {
76553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76554       };
76555     }
76556   }
76557
76558 }
76559
76560
76561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76562   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76563   Dali::Radian arg2 ;
76564   Dali::Radian arg3 ;
76565   Dali::Radian *argp2 ;
76566   Dali::Radian *argp3 ;
76567
76568   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76569   argp2 = (Dali::Radian *)jarg2;
76570   if (!argp2) {
76571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76572     return ;
76573   }
76574   arg2 = *argp2;
76575   argp3 = (Dali::Radian *)jarg3;
76576   if (!argp3) {
76577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76578     return ;
76579   }
76580   arg3 = *argp3;
76581   {
76582     try {
76583       (arg1)->SetScrollingDirection(arg2,arg3);
76584     } catch (std::out_of_range& e) {
76585       {
76586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76587       };
76588     } catch (std::exception& e) {
76589       {
76590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76591       };
76592     } catch (Dali::DaliException e) {
76593       {
76594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76595       };
76596     } catch (...) {
76597       {
76598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76599       };
76600     }
76601   }
76602
76603 }
76604
76605
76606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76608   Dali::Radian arg2 ;
76609   Dali::Radian *argp2 ;
76610
76611   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76612   argp2 = (Dali::Radian *)jarg2;
76613   if (!argp2) {
76614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76615     return ;
76616   }
76617   arg2 = *argp2;
76618   {
76619     try {
76620       (arg1)->SetScrollingDirection(arg2);
76621     } catch (std::out_of_range& e) {
76622       {
76623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76624       };
76625     } catch (std::exception& e) {
76626       {
76627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76628       };
76629     } catch (Dali::DaliException e) {
76630       {
76631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76632       };
76633     } catch (...) {
76634       {
76635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76636       };
76637     }
76638   }
76639
76640 }
76641
76642
76643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76644   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76645   Dali::Radian arg2 ;
76646   Dali::Radian *argp2 ;
76647
76648   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76649   argp2 = (Dali::Radian *)jarg2;
76650   if (!argp2) {
76651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76652     return ;
76653   }
76654   arg2 = *argp2;
76655   {
76656     try {
76657       (arg1)->RemoveScrollingDirection(arg2);
76658     } catch (std::out_of_range& e) {
76659       {
76660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76661       };
76662     } catch (std::exception& e) {
76663       {
76664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76665       };
76666     } catch (Dali::DaliException e) {
76667       {
76668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76669       };
76670     } catch (...) {
76671       {
76672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76673       };
76674     }
76675   }
76676
76677 }
76678
76679
76680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76681   void * jresult ;
76682   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76683   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76684
76685   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76686   {
76687     try {
76688       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76689     } catch (std::out_of_range& e) {
76690       {
76691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76692       };
76693     } catch (std::exception& e) {
76694       {
76695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76696       };
76697     } catch (Dali::DaliException e) {
76698       {
76699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76700       };
76701     } catch (...) {
76702       {
76703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76704       };
76705     }
76706   }
76707
76708   jresult = (void *)result;
76709   return jresult;
76710 }
76711
76712
76713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76714   int jresult ;
76715   int result;
76716
76717   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76718   jresult = (int)result;
76719   return jresult;
76720 }
76721
76722
76723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76724   int jresult ;
76725   int result;
76726
76727   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76728   jresult = (int)result;
76729   return jresult;
76730 }
76731
76732
76733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76734   int jresult ;
76735   int result;
76736
76737   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76738   jresult = (int)result;
76739   return jresult;
76740 }
76741
76742
76743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76744   int jresult ;
76745   int result;
76746
76747   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76748   jresult = (int)result;
76749   return jresult;
76750 }
76751
76752
76753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76754   int jresult ;
76755   int result;
76756
76757   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76758   jresult = (int)result;
76759   return jresult;
76760 }
76761
76762
76763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76764   void * jresult ;
76765   Dali::Toolkit::TableView::Property *result = 0 ;
76766
76767   {
76768     try {
76769       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76770     } catch (std::out_of_range& e) {
76771       {
76772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76773       };
76774     } catch (std::exception& e) {
76775       {
76776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76777       };
76778     } catch (Dali::DaliException e) {
76779       {
76780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76781       };
76782     } catch (...) {
76783       {
76784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76785       };
76786     }
76787   }
76788
76789   jresult = (void *)result;
76790   return jresult;
76791 }
76792
76793
76794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76795   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76796
76797   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76798   {
76799     try {
76800       delete arg1;
76801     } catch (std::out_of_range& e) {
76802       {
76803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76804       };
76805     } catch (std::exception& e) {
76806       {
76807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76808       };
76809     } catch (Dali::DaliException e) {
76810       {
76811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76812       };
76813     } catch (...) {
76814       {
76815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76816       };
76817     }
76818   }
76819
76820 }
76821
76822
76823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76824   int jresult ;
76825   int result;
76826
76827   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76828   jresult = (int)result;
76829   return jresult;
76830 }
76831
76832
76833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76834   int jresult ;
76835   int result;
76836
76837   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76838   jresult = (int)result;
76839   return jresult;
76840 }
76841
76842
76843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76844   int jresult ;
76845   int result;
76846
76847   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76848   jresult = (int)result;
76849   return jresult;
76850 }
76851
76852
76853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76854   int jresult ;
76855   int result;
76856
76857   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76858   jresult = (int)result;
76859   return jresult;
76860 }
76861
76862
76863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76864   int jresult ;
76865   int result;
76866
76867   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76868   jresult = (int)result;
76869   return jresult;
76870 }
76871
76872
76873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76874   void * jresult ;
76875   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76876
76877   {
76878     try {
76879       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76880     } catch (std::out_of_range& e) {
76881       {
76882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76883       };
76884     } catch (std::exception& e) {
76885       {
76886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76887       };
76888     } catch (Dali::DaliException e) {
76889       {
76890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76891       };
76892     } catch (...) {
76893       {
76894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76895       };
76896     }
76897   }
76898
76899   jresult = (void *)result;
76900   return jresult;
76901 }
76902
76903
76904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76905   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76906
76907   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76908   {
76909     try {
76910       delete arg1;
76911     } catch (std::out_of_range& e) {
76912       {
76913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76914       };
76915     } catch (std::exception& e) {
76916       {
76917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76918       };
76919     } catch (Dali::DaliException e) {
76920       {
76921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76922       };
76923     } catch (...) {
76924       {
76925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76926       };
76927     }
76928   }
76929
76930 }
76931
76932
76933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76934   void * jresult ;
76935   unsigned int arg1 ;
76936   unsigned int arg2 ;
76937   unsigned int arg3 ;
76938   unsigned int arg4 ;
76939   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76940
76941   arg1 = (unsigned int)jarg1;
76942   arg2 = (unsigned int)jarg2;
76943   arg3 = (unsigned int)jarg3;
76944   arg4 = (unsigned int)jarg4;
76945   {
76946     try {
76947       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76948     } catch (std::out_of_range& e) {
76949       {
76950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76951       };
76952     } catch (std::exception& e) {
76953       {
76954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76955       };
76956     } catch (Dali::DaliException e) {
76957       {
76958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76959       };
76960     } catch (...) {
76961       {
76962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76963       };
76964     }
76965   }
76966
76967   jresult = (void *)result;
76968   return jresult;
76969 }
76970
76971
76972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76973   void * jresult ;
76974   unsigned int arg1 ;
76975   unsigned int arg2 ;
76976   unsigned int arg3 ;
76977   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76978
76979   arg1 = (unsigned int)jarg1;
76980   arg2 = (unsigned int)jarg2;
76981   arg3 = (unsigned int)jarg3;
76982   {
76983     try {
76984       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76985     } catch (std::out_of_range& e) {
76986       {
76987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76988       };
76989     } catch (std::exception& e) {
76990       {
76991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76992       };
76993     } catch (Dali::DaliException e) {
76994       {
76995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76996       };
76997     } catch (...) {
76998       {
76999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77000       };
77001     }
77002   }
77003
77004   jresult = (void *)result;
77005   return jresult;
77006 }
77007
77008
77009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
77010   void * jresult ;
77011   unsigned int arg1 ;
77012   unsigned int arg2 ;
77013   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77014
77015   arg1 = (unsigned int)jarg1;
77016   arg2 = (unsigned int)jarg2;
77017   {
77018     try {
77019       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
77020     } catch (std::out_of_range& e) {
77021       {
77022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77023       };
77024     } catch (std::exception& e) {
77025       {
77026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77027       };
77028     } catch (Dali::DaliException e) {
77029       {
77030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77031       };
77032     } catch (...) {
77033       {
77034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77035       };
77036     }
77037   }
77038
77039   jresult = (void *)result;
77040   return jresult;
77041 }
77042
77043
77044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
77045   void * jresult ;
77046   unsigned int arg1 ;
77047   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77048
77049   arg1 = (unsigned int)jarg1;
77050   {
77051     try {
77052       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
77053     } catch (std::out_of_range& e) {
77054       {
77055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77056       };
77057     } catch (std::exception& e) {
77058       {
77059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77060       };
77061     } catch (Dali::DaliException e) {
77062       {
77063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77064       };
77065     } catch (...) {
77066       {
77067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77068       };
77069     }
77070   }
77071
77072   jresult = (void *)result;
77073   return jresult;
77074 }
77075
77076
77077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
77078   void * jresult ;
77079   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77080
77081   {
77082     try {
77083       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
77084     } catch (std::out_of_range& e) {
77085       {
77086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77087       };
77088     } catch (std::exception& e) {
77089       {
77090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77091       };
77092     } catch (Dali::DaliException e) {
77093       {
77094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77095       };
77096     } catch (...) {
77097       {
77098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77099       };
77100     }
77101   }
77102
77103   jresult = (void *)result;
77104   return jresult;
77105 }
77106
77107
77108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
77109   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77110   unsigned int arg2 ;
77111
77112   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77113   arg2 = (unsigned int)jarg2;
77114   if (arg1) (arg1)->rowIndex = arg2;
77115 }
77116
77117
77118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
77119   unsigned int jresult ;
77120   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77121   unsigned int result;
77122
77123   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77124   result = (unsigned int) ((arg1)->rowIndex);
77125   jresult = result;
77126   return jresult;
77127 }
77128
77129
77130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
77131   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77132   unsigned int arg2 ;
77133
77134   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77135   arg2 = (unsigned int)jarg2;
77136   if (arg1) (arg1)->columnIndex = arg2;
77137 }
77138
77139
77140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
77141   unsigned int jresult ;
77142   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77143   unsigned int result;
77144
77145   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77146   result = (unsigned int) ((arg1)->columnIndex);
77147   jresult = result;
77148   return jresult;
77149 }
77150
77151
77152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
77153   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77154   unsigned int arg2 ;
77155
77156   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77157   arg2 = (unsigned int)jarg2;
77158   if (arg1) (arg1)->rowSpan = arg2;
77159 }
77160
77161
77162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
77163   unsigned int jresult ;
77164   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77165   unsigned int result;
77166
77167   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77168   result = (unsigned int) ((arg1)->rowSpan);
77169   jresult = result;
77170   return jresult;
77171 }
77172
77173
77174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77175   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77176   unsigned int arg2 ;
77177
77178   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77179   arg2 = (unsigned int)jarg2;
77180   if (arg1) (arg1)->columnSpan = arg2;
77181 }
77182
77183
77184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77185   unsigned int jresult ;
77186   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77187   unsigned int result;
77188
77189   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77190   result = (unsigned int) ((arg1)->columnSpan);
77191   jresult = result;
77192   return jresult;
77193 }
77194
77195
77196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77197   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77198
77199   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77200   {
77201     try {
77202       delete arg1;
77203     } catch (std::out_of_range& e) {
77204       {
77205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77206       };
77207     } catch (std::exception& e) {
77208       {
77209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77210       };
77211     } catch (Dali::DaliException e) {
77212       {
77213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77214       };
77215     } catch (...) {
77216       {
77217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77218       };
77219     }
77220   }
77221
77222 }
77223
77224
77225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
77226   void * jresult ;
77227   Dali::Toolkit::TableView *result = 0 ;
77228
77229   {
77230     try {
77231       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
77232     } catch (std::out_of_range& e) {
77233       {
77234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77235       };
77236     } catch (std::exception& e) {
77237       {
77238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77239       };
77240     } catch (Dali::DaliException e) {
77241       {
77242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77243       };
77244     } catch (...) {
77245       {
77246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77247       };
77248     }
77249   }
77250
77251   jresult = (void *)result;
77252   return jresult;
77253 }
77254
77255
77256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77257   void * jresult ;
77258   Dali::Toolkit::TableView *arg1 = 0 ;
77259   Dali::Toolkit::TableView *result = 0 ;
77260
77261   arg1 = (Dali::Toolkit::TableView *)jarg1;
77262   if (!arg1) {
77263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77264     return 0;
77265   }
77266   {
77267     try {
77268       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77269     } catch (std::out_of_range& e) {
77270       {
77271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77272       };
77273     } catch (std::exception& e) {
77274       {
77275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77276       };
77277     } catch (Dali::DaliException e) {
77278       {
77279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77280       };
77281     } catch (...) {
77282       {
77283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77284       };
77285     }
77286   }
77287
77288   jresult = (void *)result;
77289   return jresult;
77290 }
77291
77292
77293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77294   void * jresult ;
77295   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77296   Dali::Toolkit::TableView *arg2 = 0 ;
77297   Dali::Toolkit::TableView *result = 0 ;
77298
77299   arg1 = (Dali::Toolkit::TableView *)jarg1;
77300   arg2 = (Dali::Toolkit::TableView *)jarg2;
77301   if (!arg2) {
77302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77303     return 0;
77304   }
77305   {
77306     try {
77307       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77308     } catch (std::out_of_range& e) {
77309       {
77310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77311       };
77312     } catch (std::exception& e) {
77313       {
77314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77315       };
77316     } catch (Dali::DaliException e) {
77317       {
77318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77319       };
77320     } catch (...) {
77321       {
77322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77323       };
77324     }
77325   }
77326
77327   jresult = (void *)result;
77328   return jresult;
77329 }
77330
77331
77332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77333   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77334
77335   arg1 = (Dali::Toolkit::TableView *)jarg1;
77336   {
77337     try {
77338       delete arg1;
77339     } catch (std::out_of_range& e) {
77340       {
77341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77342       };
77343     } catch (std::exception& e) {
77344       {
77345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77346       };
77347     } catch (Dali::DaliException e) {
77348       {
77349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77350       };
77351     } catch (...) {
77352       {
77353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77354       };
77355     }
77356   }
77357
77358 }
77359
77360
77361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77362   void * jresult ;
77363   unsigned int arg1 ;
77364   unsigned int arg2 ;
77365   Dali::Toolkit::TableView result;
77366
77367   arg1 = (unsigned int)jarg1;
77368   arg2 = (unsigned int)jarg2;
77369   {
77370     try {
77371       result = Dali::Toolkit::TableView::New(arg1,arg2);
77372     } catch (std::out_of_range& e) {
77373       {
77374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77375       };
77376     } catch (std::exception& e) {
77377       {
77378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77379       };
77380     } catch (Dali::DaliException e) {
77381       {
77382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77383       };
77384     } catch (...) {
77385       {
77386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77387       };
77388     }
77389   }
77390
77391   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77392   return jresult;
77393 }
77394
77395
77396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77397   void * jresult ;
77398   Dali::BaseHandle arg1 ;
77399   Dali::BaseHandle *argp1 ;
77400   Dali::Toolkit::TableView result;
77401
77402   argp1 = (Dali::BaseHandle *)jarg1;
77403   if (!argp1) {
77404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77405     return 0;
77406   }
77407   arg1 = *argp1;
77408   {
77409     try {
77410       result = Dali::Toolkit::TableView::DownCast(arg1);
77411     } catch (std::out_of_range& e) {
77412       {
77413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77414       };
77415     } catch (std::exception& e) {
77416       {
77417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77418       };
77419     } catch (Dali::DaliException e) {
77420       {
77421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77422       };
77423     } catch (...) {
77424       {
77425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77426       };
77427     }
77428   }
77429
77430   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77431   return jresult;
77432 }
77433
77434
77435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77436   unsigned int jresult ;
77437   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77438   Dali::Actor arg2 ;
77439   Dali::Toolkit::TableView::CellPosition arg3 ;
77440   Dali::Actor *argp2 ;
77441   Dali::Toolkit::TableView::CellPosition *argp3 ;
77442   bool result;
77443
77444   arg1 = (Dali::Toolkit::TableView *)jarg1;
77445   argp2 = (Dali::Actor *)jarg2;
77446   if (!argp2) {
77447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77448     return 0;
77449   }
77450   arg2 = *argp2;
77451   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77452   if (!argp3) {
77453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77454     return 0;
77455   }
77456   arg3 = *argp3;
77457   {
77458     try {
77459       result = (bool)(arg1)->AddChild(arg2,arg3);
77460     } catch (std::out_of_range& e) {
77461       {
77462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77463       };
77464     } catch (std::exception& e) {
77465       {
77466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77467       };
77468     } catch (Dali::DaliException e) {
77469       {
77470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77471       };
77472     } catch (...) {
77473       {
77474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77475       };
77476     }
77477   }
77478
77479   jresult = result;
77480   return jresult;
77481 }
77482
77483
77484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77485   void * jresult ;
77486   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77487   Dali::Toolkit::TableView::CellPosition arg2 ;
77488   Dali::Toolkit::TableView::CellPosition *argp2 ;
77489   Dali::Actor result;
77490
77491   arg1 = (Dali::Toolkit::TableView *)jarg1;
77492   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77493   if (!argp2) {
77494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77495     return 0;
77496   }
77497   arg2 = *argp2;
77498   {
77499     try {
77500       result = (arg1)->GetChildAt(arg2);
77501     } catch (std::out_of_range& e) {
77502       {
77503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77504       };
77505     } catch (std::exception& e) {
77506       {
77507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77508       };
77509     } catch (Dali::DaliException e) {
77510       {
77511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77512       };
77513     } catch (...) {
77514       {
77515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77516       };
77517     }
77518   }
77519
77520   jresult = new Dali::Actor((const Dali::Actor &)result);
77521   return jresult;
77522 }
77523
77524
77525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77526   void * jresult ;
77527   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77528   Dali::Toolkit::TableView::CellPosition arg2 ;
77529   Dali::Toolkit::TableView::CellPosition *argp2 ;
77530   Dali::Actor result;
77531
77532   arg1 = (Dali::Toolkit::TableView *)jarg1;
77533   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77534   if (!argp2) {
77535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77536     return 0;
77537   }
77538   arg2 = *argp2;
77539   {
77540     try {
77541       result = (arg1)->RemoveChildAt(arg2);
77542     } catch (std::out_of_range& e) {
77543       {
77544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77545       };
77546     } catch (std::exception& e) {
77547       {
77548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77549       };
77550     } catch (Dali::DaliException e) {
77551       {
77552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77553       };
77554     } catch (...) {
77555       {
77556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77557       };
77558     }
77559   }
77560
77561   jresult = new Dali::Actor((const Dali::Actor &)result);
77562   return jresult;
77563 }
77564
77565
77566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77567   unsigned int jresult ;
77568   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77569   Dali::Actor arg2 ;
77570   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77571   Dali::Actor *argp2 ;
77572   bool result;
77573
77574   arg1 = (Dali::Toolkit::TableView *)jarg1;
77575   argp2 = (Dali::Actor *)jarg2;
77576   if (!argp2) {
77577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77578     return 0;
77579   }
77580   arg2 = *argp2;
77581   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77582   if (!arg3) {
77583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77584     return 0;
77585   }
77586   {
77587     try {
77588       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77589     } catch (std::out_of_range& e) {
77590       {
77591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77592       };
77593     } catch (std::exception& e) {
77594       {
77595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77596       };
77597     } catch (Dali::DaliException e) {
77598       {
77599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77600       };
77601     } catch (...) {
77602       {
77603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77604       };
77605     }
77606   }
77607
77608   jresult = result;
77609   return jresult;
77610 }
77611
77612
77613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77614   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77615   unsigned int arg2 ;
77616
77617   arg1 = (Dali::Toolkit::TableView *)jarg1;
77618   arg2 = (unsigned int)jarg2;
77619   {
77620     try {
77621       (arg1)->InsertRow(arg2);
77622     } catch (std::out_of_range& e) {
77623       {
77624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77625       };
77626     } catch (std::exception& e) {
77627       {
77628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77629       };
77630     } catch (Dali::DaliException e) {
77631       {
77632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77633       };
77634     } catch (...) {
77635       {
77636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77637       };
77638     }
77639   }
77640
77641 }
77642
77643
77644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77645   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77646   unsigned int arg2 ;
77647
77648   arg1 = (Dali::Toolkit::TableView *)jarg1;
77649   arg2 = (unsigned int)jarg2;
77650   {
77651     try {
77652       (arg1)->DeleteRow(arg2);
77653     } catch (std::out_of_range& e) {
77654       {
77655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77656       };
77657     } catch (std::exception& e) {
77658       {
77659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77660       };
77661     } catch (Dali::DaliException e) {
77662       {
77663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77664       };
77665     } catch (...) {
77666       {
77667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77668       };
77669     }
77670   }
77671
77672 }
77673
77674
77675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77676   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77677   unsigned int arg2 ;
77678   std::vector< Dali::Actor > *arg3 = 0 ;
77679
77680   arg1 = (Dali::Toolkit::TableView *)jarg1;
77681   arg2 = (unsigned int)jarg2;
77682   arg3 = (std::vector< Dali::Actor > *)jarg3;
77683   if (!arg3) {
77684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77685     return ;
77686   }
77687   {
77688     try {
77689       (arg1)->DeleteRow(arg2,*arg3);
77690     } catch (std::out_of_range& e) {
77691       {
77692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77693       };
77694     } catch (std::exception& e) {
77695       {
77696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77697       };
77698     } catch (Dali::DaliException e) {
77699       {
77700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77701       };
77702     } catch (...) {
77703       {
77704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77705       };
77706     }
77707   }
77708
77709 }
77710
77711
77712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77713   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77714   unsigned int arg2 ;
77715
77716   arg1 = (Dali::Toolkit::TableView *)jarg1;
77717   arg2 = (unsigned int)jarg2;
77718   {
77719     try {
77720       (arg1)->InsertColumn(arg2);
77721     } catch (std::out_of_range& e) {
77722       {
77723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77724       };
77725     } catch (std::exception& e) {
77726       {
77727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77728       };
77729     } catch (Dali::DaliException e) {
77730       {
77731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77732       };
77733     } catch (...) {
77734       {
77735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77736       };
77737     }
77738   }
77739
77740 }
77741
77742
77743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77744   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77745   unsigned int arg2 ;
77746
77747   arg1 = (Dali::Toolkit::TableView *)jarg1;
77748   arg2 = (unsigned int)jarg2;
77749   {
77750     try {
77751       (arg1)->DeleteColumn(arg2);
77752     } catch (std::out_of_range& e) {
77753       {
77754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77755       };
77756     } catch (std::exception& e) {
77757       {
77758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77759       };
77760     } catch (Dali::DaliException e) {
77761       {
77762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77763       };
77764     } catch (...) {
77765       {
77766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77767       };
77768     }
77769   }
77770
77771 }
77772
77773
77774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77775   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77776   unsigned int arg2 ;
77777   std::vector< Dali::Actor > *arg3 = 0 ;
77778
77779   arg1 = (Dali::Toolkit::TableView *)jarg1;
77780   arg2 = (unsigned int)jarg2;
77781   arg3 = (std::vector< Dali::Actor > *)jarg3;
77782   if (!arg3) {
77783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77784     return ;
77785   }
77786   {
77787     try {
77788       (arg1)->DeleteColumn(arg2,*arg3);
77789     } catch (std::out_of_range& e) {
77790       {
77791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77792       };
77793     } catch (std::exception& e) {
77794       {
77795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77796       };
77797     } catch (Dali::DaliException e) {
77798       {
77799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77800       };
77801     } catch (...) {
77802       {
77803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77804       };
77805     }
77806   }
77807
77808 }
77809
77810
77811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77812   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77813   unsigned int arg2 ;
77814   unsigned int arg3 ;
77815
77816   arg1 = (Dali::Toolkit::TableView *)jarg1;
77817   arg2 = (unsigned int)jarg2;
77818   arg3 = (unsigned int)jarg3;
77819   {
77820     try {
77821       (arg1)->Resize(arg2,arg3);
77822     } catch (std::out_of_range& e) {
77823       {
77824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77825       };
77826     } catch (std::exception& e) {
77827       {
77828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77829       };
77830     } catch (Dali::DaliException e) {
77831       {
77832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77833       };
77834     } catch (...) {
77835       {
77836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77837       };
77838     }
77839   }
77840
77841 }
77842
77843
77844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77845   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77846   unsigned int arg2 ;
77847   unsigned int arg3 ;
77848   std::vector< Dali::Actor > *arg4 = 0 ;
77849
77850   arg1 = (Dali::Toolkit::TableView *)jarg1;
77851   arg2 = (unsigned int)jarg2;
77852   arg3 = (unsigned int)jarg3;
77853   arg4 = (std::vector< Dali::Actor > *)jarg4;
77854   if (!arg4) {
77855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77856     return ;
77857   }
77858   {
77859     try {
77860       (arg1)->Resize(arg2,arg3,*arg4);
77861     } catch (std::out_of_range& e) {
77862       {
77863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77864       };
77865     } catch (std::exception& e) {
77866       {
77867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77868       };
77869     } catch (Dali::DaliException e) {
77870       {
77871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77872       };
77873     } catch (...) {
77874       {
77875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77876       };
77877     }
77878   }
77879
77880 }
77881
77882
77883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77884   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77885   Dali::Size arg2 ;
77886   Dali::Size *argp2 ;
77887
77888   arg1 = (Dali::Toolkit::TableView *)jarg1;
77889   argp2 = (Dali::Size *)jarg2;
77890   if (!argp2) {
77891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77892     return ;
77893   }
77894   arg2 = *argp2;
77895   {
77896     try {
77897       (arg1)->SetCellPadding(arg2);
77898     } catch (std::out_of_range& e) {
77899       {
77900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77901       };
77902     } catch (std::exception& e) {
77903       {
77904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77905       };
77906     } catch (Dali::DaliException e) {
77907       {
77908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77909       };
77910     } catch (...) {
77911       {
77912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77913       };
77914     }
77915   }
77916
77917 }
77918
77919
77920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77921   void * jresult ;
77922   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77923   Dali::Size result;
77924
77925   arg1 = (Dali::Toolkit::TableView *)jarg1;
77926   {
77927     try {
77928       result = (arg1)->GetCellPadding();
77929     } catch (std::out_of_range& e) {
77930       {
77931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77932       };
77933     } catch (std::exception& e) {
77934       {
77935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77936       };
77937     } catch (Dali::DaliException e) {
77938       {
77939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77940       };
77941     } catch (...) {
77942       {
77943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77944       };
77945     }
77946   }
77947
77948   jresult = new Dali::Size((const Dali::Size &)result);
77949   return jresult;
77950 }
77951
77952
77953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77954   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77955   unsigned int arg2 ;
77956
77957   arg1 = (Dali::Toolkit::TableView *)jarg1;
77958   arg2 = (unsigned int)jarg2;
77959   {
77960     try {
77961       (arg1)->SetFitHeight(arg2);
77962     } catch (std::out_of_range& e) {
77963       {
77964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77965       };
77966     } catch (std::exception& e) {
77967       {
77968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77969       };
77970     } catch (Dali::DaliException e) {
77971       {
77972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77973       };
77974     } catch (...) {
77975       {
77976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77977       };
77978     }
77979   }
77980
77981 }
77982
77983
77984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77985   unsigned int jresult ;
77986   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77987   unsigned int arg2 ;
77988   bool result;
77989
77990   arg1 = (Dali::Toolkit::TableView *)jarg1;
77991   arg2 = (unsigned int)jarg2;
77992   {
77993     try {
77994       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77995     } catch (std::out_of_range& e) {
77996       {
77997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77998       };
77999     } catch (std::exception& e) {
78000       {
78001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78002       };
78003     } catch (Dali::DaliException e) {
78004       {
78005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78006       };
78007     } catch (...) {
78008       {
78009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78010       };
78011     }
78012   }
78013
78014   jresult = result;
78015   return jresult;
78016 }
78017
78018
78019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
78020   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78021   unsigned int arg2 ;
78022
78023   arg1 = (Dali::Toolkit::TableView *)jarg1;
78024   arg2 = (unsigned int)jarg2;
78025   {
78026     try {
78027       (arg1)->SetFitWidth(arg2);
78028     } catch (std::out_of_range& e) {
78029       {
78030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78031       };
78032     } catch (std::exception& e) {
78033       {
78034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78035       };
78036     } catch (Dali::DaliException e) {
78037       {
78038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78039       };
78040     } catch (...) {
78041       {
78042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78043       };
78044     }
78045   }
78046
78047 }
78048
78049
78050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
78051   unsigned int jresult ;
78052   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78053   unsigned int arg2 ;
78054   bool result;
78055
78056   arg1 = (Dali::Toolkit::TableView *)jarg1;
78057   arg2 = (unsigned int)jarg2;
78058   {
78059     try {
78060       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
78061     } catch (std::out_of_range& e) {
78062       {
78063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78064       };
78065     } catch (std::exception& e) {
78066       {
78067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78068       };
78069     } catch (Dali::DaliException e) {
78070       {
78071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78072       };
78073     } catch (...) {
78074       {
78075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78076       };
78077     }
78078   }
78079
78080   jresult = result;
78081   return jresult;
78082 }
78083
78084
78085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78086   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78087   unsigned int arg2 ;
78088   float arg3 ;
78089
78090   arg1 = (Dali::Toolkit::TableView *)jarg1;
78091   arg2 = (unsigned int)jarg2;
78092   arg3 = (float)jarg3;
78093   {
78094     try {
78095       (arg1)->SetFixedHeight(arg2,arg3);
78096     } catch (std::out_of_range& e) {
78097       {
78098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78099       };
78100     } catch (std::exception& e) {
78101       {
78102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78103       };
78104     } catch (Dali::DaliException e) {
78105       {
78106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78107       };
78108     } catch (...) {
78109       {
78110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78111       };
78112     }
78113   }
78114
78115 }
78116
78117
78118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
78119   float jresult ;
78120   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78121   unsigned int arg2 ;
78122   float result;
78123
78124   arg1 = (Dali::Toolkit::TableView *)jarg1;
78125   arg2 = (unsigned int)jarg2;
78126   {
78127     try {
78128       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
78129     } catch (std::out_of_range& e) {
78130       {
78131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78132       };
78133     } catch (std::exception& e) {
78134       {
78135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78136       };
78137     } catch (Dali::DaliException e) {
78138       {
78139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78140       };
78141     } catch (...) {
78142       {
78143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78144       };
78145     }
78146   }
78147
78148   jresult = result;
78149   return jresult;
78150 }
78151
78152
78153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78154   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78155   unsigned int arg2 ;
78156   float arg3 ;
78157
78158   arg1 = (Dali::Toolkit::TableView *)jarg1;
78159   arg2 = (unsigned int)jarg2;
78160   arg3 = (float)jarg3;
78161   {
78162     try {
78163       (arg1)->SetRelativeHeight(arg2,arg3);
78164     } catch (std::out_of_range& e) {
78165       {
78166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78167       };
78168     } catch (std::exception& e) {
78169       {
78170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78171       };
78172     } catch (Dali::DaliException e) {
78173       {
78174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78175       };
78176     } catch (...) {
78177       {
78178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78179       };
78180     }
78181   }
78182
78183 }
78184
78185
78186 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78187   float jresult ;
78188   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78189   unsigned int arg2 ;
78190   float result;
78191
78192   arg1 = (Dali::Toolkit::TableView *)jarg1;
78193   arg2 = (unsigned int)jarg2;
78194   {
78195     try {
78196       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78197     } catch (std::out_of_range& e) {
78198       {
78199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78200       };
78201     } catch (std::exception& e) {
78202       {
78203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78204       };
78205     } catch (Dali::DaliException e) {
78206       {
78207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78208       };
78209     } catch (...) {
78210       {
78211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78212       };
78213     }
78214   }
78215
78216   jresult = result;
78217   return jresult;
78218 }
78219
78220
78221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78222   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78223   unsigned int arg2 ;
78224   float arg3 ;
78225
78226   arg1 = (Dali::Toolkit::TableView *)jarg1;
78227   arg2 = (unsigned int)jarg2;
78228   arg3 = (float)jarg3;
78229   {
78230     try {
78231       (arg1)->SetFixedWidth(arg2,arg3);
78232     } catch (std::out_of_range& e) {
78233       {
78234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78235       };
78236     } catch (std::exception& e) {
78237       {
78238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78239       };
78240     } catch (Dali::DaliException e) {
78241       {
78242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78243       };
78244     } catch (...) {
78245       {
78246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78247       };
78248     }
78249   }
78250
78251 }
78252
78253
78254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78255   float jresult ;
78256   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78257   unsigned int arg2 ;
78258   float result;
78259
78260   arg1 = (Dali::Toolkit::TableView *)jarg1;
78261   arg2 = (unsigned int)jarg2;
78262   {
78263     try {
78264       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78265     } catch (std::out_of_range& e) {
78266       {
78267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78268       };
78269     } catch (std::exception& e) {
78270       {
78271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78272       };
78273     } catch (Dali::DaliException e) {
78274       {
78275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78276       };
78277     } catch (...) {
78278       {
78279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78280       };
78281     }
78282   }
78283
78284   jresult = result;
78285   return jresult;
78286 }
78287
78288
78289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78290   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78291   unsigned int arg2 ;
78292   float arg3 ;
78293
78294   arg1 = (Dali::Toolkit::TableView *)jarg1;
78295   arg2 = (unsigned int)jarg2;
78296   arg3 = (float)jarg3;
78297   {
78298     try {
78299       (arg1)->SetRelativeWidth(arg2,arg3);
78300     } catch (std::out_of_range& e) {
78301       {
78302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78303       };
78304     } catch (std::exception& e) {
78305       {
78306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78307       };
78308     } catch (Dali::DaliException e) {
78309       {
78310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78311       };
78312     } catch (...) {
78313       {
78314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78315       };
78316     }
78317   }
78318
78319 }
78320
78321
78322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78323   float jresult ;
78324   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78325   unsigned int arg2 ;
78326   float result;
78327
78328   arg1 = (Dali::Toolkit::TableView *)jarg1;
78329   arg2 = (unsigned int)jarg2;
78330   {
78331     try {
78332       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78333     } catch (std::out_of_range& e) {
78334       {
78335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78336       };
78337     } catch (std::exception& e) {
78338       {
78339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78340       };
78341     } catch (Dali::DaliException e) {
78342       {
78343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78344       };
78345     } catch (...) {
78346       {
78347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78348       };
78349     }
78350   }
78351
78352   jresult = result;
78353   return jresult;
78354 }
78355
78356
78357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78358   unsigned int jresult ;
78359   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78360   unsigned int result;
78361
78362   arg1 = (Dali::Toolkit::TableView *)jarg1;
78363   {
78364     try {
78365       result = (unsigned int)(arg1)->GetRows();
78366     } catch (std::out_of_range& e) {
78367       {
78368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78369       };
78370     } catch (std::exception& e) {
78371       {
78372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78373       };
78374     } catch (Dali::DaliException e) {
78375       {
78376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78377       };
78378     } catch (...) {
78379       {
78380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78381       };
78382     }
78383   }
78384
78385   jresult = result;
78386   return jresult;
78387 }
78388
78389
78390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78391   unsigned int jresult ;
78392   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78393   unsigned int result;
78394
78395   arg1 = (Dali::Toolkit::TableView *)jarg1;
78396   {
78397     try {
78398       result = (unsigned int)(arg1)->GetColumns();
78399     } catch (std::out_of_range& e) {
78400       {
78401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78402       };
78403     } catch (std::exception& e) {
78404       {
78405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78406       };
78407     } catch (Dali::DaliException e) {
78408       {
78409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78410       };
78411     } catch (...) {
78412       {
78413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78414       };
78415     }
78416   }
78417
78418   jresult = result;
78419   return jresult;
78420 }
78421
78422
78423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78424   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78425   Dali::Toolkit::TableView::CellPosition arg2 ;
78426   Dali::HorizontalAlignment::Type arg3 ;
78427   Dali::VerticalAlignment::Type arg4 ;
78428   Dali::Toolkit::TableView::CellPosition *argp2 ;
78429
78430   arg1 = (Dali::Toolkit::TableView *)jarg1;
78431   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78432   if (!argp2) {
78433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78434     return ;
78435   }
78436   arg2 = *argp2;
78437   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78438   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78439   {
78440     try {
78441       (arg1)->SetCellAlignment(arg2,arg3,arg4);
78442     } catch (std::out_of_range& e) {
78443       {
78444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78445       };
78446     } catch (std::exception& e) {
78447       {
78448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78449       };
78450     } catch (Dali::DaliException e) {
78451       {
78452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78453       };
78454     } catch (...) {
78455       {
78456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78457       };
78458     }
78459   }
78460
78461 }
78462
78463
78464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
78465   unsigned int jresult ;
78466   unsigned int result;
78467
78468   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78469   jresult = result;
78470   return jresult;
78471 }
78472
78473
78474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78475   int jresult ;
78476   int result;
78477
78478   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78479   jresult = (int)result;
78480   return jresult;
78481 }
78482
78483
78484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78485   int jresult ;
78486   int result;
78487
78488   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78489   jresult = (int)result;
78490   return jresult;
78491 }
78492
78493
78494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78495   int jresult ;
78496   int result;
78497
78498   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78499   jresult = (int)result;
78500   return jresult;
78501 }
78502
78503
78504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78505   int jresult ;
78506   int result;
78507
78508   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78509   jresult = (int)result;
78510   return jresult;
78511 }
78512
78513
78514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78515   int jresult ;
78516   int result;
78517
78518   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78519   jresult = (int)result;
78520   return jresult;
78521 }
78522
78523
78524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78525   int jresult ;
78526   int result;
78527
78528   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78529   jresult = (int)result;
78530   return jresult;
78531 }
78532
78533
78534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78535   int jresult ;
78536   int result;
78537
78538   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78539   jresult = (int)result;
78540   return jresult;
78541 }
78542
78543
78544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78545   int jresult ;
78546   int result;
78547
78548   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78549   jresult = (int)result;
78550   return jresult;
78551 }
78552
78553
78554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78555   int jresult ;
78556   int result;
78557
78558   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78559   jresult = (int)result;
78560   return jresult;
78561 }
78562
78563
78564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78565   int jresult ;
78566   int result;
78567
78568   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78569   jresult = (int)result;
78570   return jresult;
78571 }
78572
78573
78574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78575   int jresult ;
78576   int result;
78577
78578   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78579   jresult = (int)result;
78580   return jresult;
78581 }
78582
78583
78584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78585   int jresult ;
78586   int result;
78587
78588   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78589   jresult = (int)result;
78590   return jresult;
78591 }
78592
78593
78594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78595   int jresult ;
78596   int result;
78597
78598   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78599   jresult = (int)result;
78600   return jresult;
78601 }
78602
78603
78604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78605   int jresult ;
78606   int result;
78607
78608   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78609   jresult = (int)result;
78610   return jresult;
78611 }
78612
78613
78614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78615   int jresult ;
78616   int result;
78617
78618   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78619   jresult = (int)result;
78620   return jresult;
78621 }
78622
78623
78624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78625   int jresult ;
78626   int result;
78627
78628   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78629   jresult = (int)result;
78630   return jresult;
78631 }
78632
78633
78634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78635   int jresult ;
78636   int result;
78637
78638   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78639   jresult = (int)result;
78640   return jresult;
78641 }
78642
78643
78644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78645   int jresult ;
78646   int result;
78647
78648   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78649   jresult = (int)result;
78650   return jresult;
78651 }
78652
78653
78654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78655   void * jresult ;
78656   Dali::Toolkit::TextLabel::Property *result = 0 ;
78657
78658   {
78659     try {
78660       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78661     } catch (std::out_of_range& e) {
78662       {
78663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78664       };
78665     } catch (std::exception& e) {
78666       {
78667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78668       };
78669     } catch (Dali::DaliException e) {
78670       {
78671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78672       };
78673     } catch (...) {
78674       {
78675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78676       };
78677     }
78678   }
78679
78680   jresult = (void *)result;
78681   return jresult;
78682 }
78683
78684
78685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78686   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78687
78688   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78689   {
78690     try {
78691       delete arg1;
78692     } catch (std::out_of_range& e) {
78693       {
78694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78695       };
78696     } catch (std::exception& e) {
78697       {
78698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78699       };
78700     } catch (Dali::DaliException e) {
78701       {
78702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78703       };
78704     } catch (...) {
78705       {
78706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78707       };
78708     }
78709   }
78710
78711 }
78712
78713
78714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78715   void * jresult ;
78716   Dali::Toolkit::TextLabel result;
78717
78718   {
78719     try {
78720       result = Dali::Toolkit::TextLabel::New();
78721     } catch (std::out_of_range& e) {
78722       {
78723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78724       };
78725     } catch (std::exception& e) {
78726       {
78727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78728       };
78729     } catch (Dali::DaliException e) {
78730       {
78731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78732       };
78733     } catch (...) {
78734       {
78735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78736       };
78737     }
78738   }
78739
78740   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78741   return jresult;
78742 }
78743
78744
78745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78746   void * jresult ;
78747   std::string *arg1 = 0 ;
78748   Dali::Toolkit::TextLabel result;
78749
78750   if (!jarg1) {
78751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78752     return 0;
78753   }
78754   std::string arg1_str(jarg1);
78755   arg1 = &arg1_str;
78756   {
78757     try {
78758       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78759     } catch (std::out_of_range& e) {
78760       {
78761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78762       };
78763     } catch (std::exception& e) {
78764       {
78765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78766       };
78767     } catch (Dali::DaliException e) {
78768       {
78769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78770       };
78771     } catch (...) {
78772       {
78773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78774       };
78775     }
78776   }
78777
78778   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78779
78780   //argout typemap for const std::string&
78781
78782   return jresult;
78783 }
78784
78785
78786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78787   void * jresult ;
78788   Dali::Toolkit::TextLabel *result = 0 ;
78789
78790   {
78791     try {
78792       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78793     } catch (std::out_of_range& e) {
78794       {
78795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78796       };
78797     } catch (std::exception& e) {
78798       {
78799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78800       };
78801     } catch (Dali::DaliException e) {
78802       {
78803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78804       };
78805     } catch (...) {
78806       {
78807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78808       };
78809     }
78810   }
78811
78812   jresult = (void *)result;
78813   return jresult;
78814 }
78815
78816
78817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78818   void * jresult ;
78819   Dali::Toolkit::TextLabel *arg1 = 0 ;
78820   Dali::Toolkit::TextLabel *result = 0 ;
78821
78822   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78823   if (!arg1) {
78824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78825     return 0;
78826   }
78827   {
78828     try {
78829       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78830     } catch (std::out_of_range& e) {
78831       {
78832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78833       };
78834     } catch (std::exception& e) {
78835       {
78836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78837       };
78838     } catch (Dali::DaliException e) {
78839       {
78840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78841       };
78842     } catch (...) {
78843       {
78844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78845       };
78846     }
78847   }
78848
78849   jresult = (void *)result;
78850   return jresult;
78851 }
78852
78853
78854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78855   void * jresult ;
78856   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78857   Dali::Toolkit::TextLabel *arg2 = 0 ;
78858   Dali::Toolkit::TextLabel *result = 0 ;
78859
78860   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78861   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78862   if (!arg2) {
78863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78864     return 0;
78865   }
78866   {
78867     try {
78868       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78869     } catch (std::out_of_range& e) {
78870       {
78871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78872       };
78873     } catch (std::exception& e) {
78874       {
78875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78876       };
78877     } catch (Dali::DaliException e) {
78878       {
78879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78880       };
78881     } catch (...) {
78882       {
78883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78884       };
78885     }
78886   }
78887
78888   jresult = (void *)result;
78889   return jresult;
78890 }
78891
78892
78893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78894   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78895
78896   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78897   {
78898     try {
78899       delete arg1;
78900     } catch (std::out_of_range& e) {
78901       {
78902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78903       };
78904     } catch (std::exception& e) {
78905       {
78906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78907       };
78908     } catch (Dali::DaliException e) {
78909       {
78910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78911       };
78912     } catch (...) {
78913       {
78914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78915       };
78916     }
78917   }
78918
78919 }
78920
78921
78922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78923   void * jresult ;
78924   Dali::BaseHandle arg1 ;
78925   Dali::BaseHandle *argp1 ;
78926   Dali::Toolkit::TextLabel result;
78927
78928   argp1 = (Dali::BaseHandle *)jarg1;
78929   if (!argp1) {
78930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78931     return 0;
78932   }
78933   arg1 = *argp1;
78934   {
78935     try {
78936       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78937     } catch (std::out_of_range& e) {
78938       {
78939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78940       };
78941     } catch (std::exception& e) {
78942       {
78943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78944       };
78945     } catch (Dali::DaliException e) {
78946       {
78947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78948       };
78949     } catch (...) {
78950       {
78951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78952       };
78953     }
78954   }
78955
78956   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78957   return jresult;
78958 }
78959
78960
78961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78962   void * jresult ;
78963   Dali::Toolkit::AccessibilityManager *result = 0 ;
78964
78965   {
78966     try {
78967       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78968     } catch (std::out_of_range& e) {
78969       {
78970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78971       };
78972     } catch (std::exception& e) {
78973       {
78974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78975       };
78976     } catch (Dali::DaliException e) {
78977       {
78978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78979       };
78980     } catch (...) {
78981       {
78982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78983       };
78984     }
78985   }
78986
78987   jresult = (void *)result;
78988   return jresult;
78989 }
78990
78991
78992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78993   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78994
78995   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78996   {
78997     try {
78998       delete arg1;
78999     } catch (std::out_of_range& e) {
79000       {
79001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79002       };
79003     } catch (std::exception& e) {
79004       {
79005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79006       };
79007     } catch (Dali::DaliException e) {
79008       {
79009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79010       };
79011     } catch (...) {
79012       {
79013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79014       };
79015     }
79016   }
79017
79018 }
79019
79020
79021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79022   void * jresult ;
79023   Dali::Toolkit::AccessibilityManager result;
79024
79025   {
79026     try {
79027       result = Dali::Toolkit::AccessibilityManager::Get();
79028     } catch (std::out_of_range& e) {
79029       {
79030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79031       };
79032     } catch (std::exception& e) {
79033       {
79034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79035       };
79036     } catch (Dali::DaliException e) {
79037       {
79038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79039       };
79040     } catch (...) {
79041       {
79042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79043       };
79044     }
79045   }
79046
79047   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79048   return jresult;
79049 }
79050
79051
79052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79053   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79054   Dali::Actor arg2 ;
79055   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79056   std::string *arg4 = 0 ;
79057   Dali::Actor *argp2 ;
79058
79059   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79060   argp2 = (Dali::Actor *)jarg2;
79061   if (!argp2) {
79062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79063     return ;
79064   }
79065   arg2 = *argp2;
79066   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79067   if (!jarg4) {
79068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79069     return ;
79070   }
79071   std::string arg4_str(jarg4);
79072   arg4 = &arg4_str;
79073   {
79074     try {
79075       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79076     } catch (std::out_of_range& e) {
79077       {
79078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79079       };
79080     } catch (std::exception& e) {
79081       {
79082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79083       };
79084     } catch (Dali::DaliException e) {
79085       {
79086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79087       };
79088     } catch (...) {
79089       {
79090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79091       };
79092     }
79093   }
79094
79095
79096   //argout typemap for const std::string&
79097
79098 }
79099
79100
79101 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79102   char * jresult ;
79103   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79104   Dali::Actor arg2 ;
79105   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79106   Dali::Actor *argp2 ;
79107   std::string result;
79108
79109   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79110   argp2 = (Dali::Actor *)jarg2;
79111   if (!argp2) {
79112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79113     return 0;
79114   }
79115   arg2 = *argp2;
79116   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79117   {
79118     try {
79119       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79120     } catch (std::out_of_range& e) {
79121       {
79122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79123       };
79124     } catch (std::exception& e) {
79125       {
79126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79127       };
79128     } catch (Dali::DaliException e) {
79129       {
79130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79131       };
79132     } catch (...) {
79133       {
79134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79135       };
79136     }
79137   }
79138
79139   jresult = SWIG_csharp_string_callback((&result)->c_str());
79140   return jresult;
79141 }
79142
79143
79144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79145   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79146   Dali::Actor arg2 ;
79147   unsigned int arg3 ;
79148   Dali::Actor *argp2 ;
79149
79150   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79151   argp2 = (Dali::Actor *)jarg2;
79152   if (!argp2) {
79153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79154     return ;
79155   }
79156   arg2 = *argp2;
79157   arg3 = (unsigned int)jarg3;
79158   {
79159     try {
79160       (arg1)->SetFocusOrder(arg2,arg3);
79161     } catch (std::out_of_range& e) {
79162       {
79163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79164       };
79165     } catch (std::exception& e) {
79166       {
79167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79168       };
79169     } catch (Dali::DaliException e) {
79170       {
79171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79172       };
79173     } catch (...) {
79174       {
79175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79176       };
79177     }
79178   }
79179
79180 }
79181
79182
79183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79184   unsigned int jresult ;
79185   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79186   Dali::Actor arg2 ;
79187   Dali::Actor *argp2 ;
79188   unsigned int result;
79189
79190   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79191   argp2 = (Dali::Actor *)jarg2;
79192   if (!argp2) {
79193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79194     return 0;
79195   }
79196   arg2 = *argp2;
79197   {
79198     try {
79199       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79200     } catch (std::out_of_range& e) {
79201       {
79202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79203       };
79204     } catch (std::exception& e) {
79205       {
79206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79207       };
79208     } catch (Dali::DaliException e) {
79209       {
79210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79211       };
79212     } catch (...) {
79213       {
79214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79215       };
79216     }
79217   }
79218
79219   jresult = result;
79220   return jresult;
79221 }
79222
79223
79224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79225   unsigned int jresult ;
79226   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79227   unsigned int result;
79228
79229   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79230   {
79231     try {
79232       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79233     } catch (std::out_of_range& e) {
79234       {
79235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79236       };
79237     } catch (std::exception& e) {
79238       {
79239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79240       };
79241     } catch (Dali::DaliException e) {
79242       {
79243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79244       };
79245     } catch (...) {
79246       {
79247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79248       };
79249     }
79250   }
79251
79252   jresult = result;
79253   return jresult;
79254 }
79255
79256
79257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79258   void * jresult ;
79259   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79260   unsigned int arg2 ;
79261   Dali::Actor result;
79262
79263   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79264   arg2 = (unsigned int)jarg2;
79265   {
79266     try {
79267       result = (arg1)->GetActorByFocusOrder(arg2);
79268     } catch (std::out_of_range& e) {
79269       {
79270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79271       };
79272     } catch (std::exception& e) {
79273       {
79274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79275       };
79276     } catch (Dali::DaliException e) {
79277       {
79278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79279       };
79280     } catch (...) {
79281       {
79282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79283       };
79284     }
79285   }
79286
79287   jresult = new Dali::Actor((const Dali::Actor &)result);
79288   return jresult;
79289 }
79290
79291
79292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79293   unsigned int jresult ;
79294   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79295   Dali::Actor arg2 ;
79296   Dali::Actor *argp2 ;
79297   bool result;
79298
79299   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79300   argp2 = (Dali::Actor *)jarg2;
79301   if (!argp2) {
79302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79303     return 0;
79304   }
79305   arg2 = *argp2;
79306   {
79307     try {
79308       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79309     } catch (std::out_of_range& e) {
79310       {
79311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79312       };
79313     } catch (std::exception& e) {
79314       {
79315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79316       };
79317     } catch (Dali::DaliException e) {
79318       {
79319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79320       };
79321     } catch (...) {
79322       {
79323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79324       };
79325     }
79326   }
79327
79328   jresult = result;
79329   return jresult;
79330 }
79331
79332
79333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79334   void * jresult ;
79335   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79336   Dali::Actor result;
79337
79338   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79339   {
79340     try {
79341       result = (arg1)->GetCurrentFocusActor();
79342     } catch (std::out_of_range& e) {
79343       {
79344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79345       };
79346     } catch (std::exception& e) {
79347       {
79348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79349       };
79350     } catch (Dali::DaliException e) {
79351       {
79352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79353       };
79354     } catch (...) {
79355       {
79356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79357       };
79358     }
79359   }
79360
79361   jresult = new Dali::Actor((const Dali::Actor &)result);
79362   return jresult;
79363 }
79364
79365
79366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79367   void * jresult ;
79368   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79369   Dali::Actor result;
79370
79371   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79372   {
79373     try {
79374       result = (arg1)->GetCurrentFocusGroup();
79375     } catch (std::out_of_range& e) {
79376       {
79377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79378       };
79379     } catch (std::exception& e) {
79380       {
79381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79382       };
79383     } catch (Dali::DaliException e) {
79384       {
79385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79386       };
79387     } catch (...) {
79388       {
79389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79390       };
79391     }
79392   }
79393
79394   jresult = new Dali::Actor((const Dali::Actor &)result);
79395   return jresult;
79396 }
79397
79398
79399 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79400   unsigned int jresult ;
79401   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79402   unsigned int result;
79403
79404   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79405   {
79406     try {
79407       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79408     } catch (std::out_of_range& e) {
79409       {
79410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79411       };
79412     } catch (std::exception& e) {
79413       {
79414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79415       };
79416     } catch (Dali::DaliException e) {
79417       {
79418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79419       };
79420     } catch (...) {
79421       {
79422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79423       };
79424     }
79425   }
79426
79427   jresult = result;
79428   return jresult;
79429 }
79430
79431
79432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79433   unsigned int jresult ;
79434   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79435   bool result;
79436
79437   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79438   {
79439     try {
79440       result = (bool)(arg1)->MoveFocusForward();
79441     } catch (std::out_of_range& e) {
79442       {
79443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79444       };
79445     } catch (std::exception& e) {
79446       {
79447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79448       };
79449     } catch (Dali::DaliException e) {
79450       {
79451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79452       };
79453     } catch (...) {
79454       {
79455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79456       };
79457     }
79458   }
79459
79460   jresult = result;
79461   return jresult;
79462 }
79463
79464
79465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79466   unsigned int jresult ;
79467   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79468   bool result;
79469
79470   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79471   {
79472     try {
79473       result = (bool)(arg1)->MoveFocusBackward();
79474     } catch (std::out_of_range& e) {
79475       {
79476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79477       };
79478     } catch (std::exception& e) {
79479       {
79480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79481       };
79482     } catch (Dali::DaliException e) {
79483       {
79484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79485       };
79486     } catch (...) {
79487       {
79488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79489       };
79490     }
79491   }
79492
79493   jresult = result;
79494   return jresult;
79495 }
79496
79497
79498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79499   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79500
79501   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79502   {
79503     try {
79504       (arg1)->ClearFocus();
79505     } catch (std::out_of_range& e) {
79506       {
79507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79508       };
79509     } catch (std::exception& e) {
79510       {
79511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79512       };
79513     } catch (Dali::DaliException e) {
79514       {
79515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79516       };
79517     } catch (...) {
79518       {
79519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79520       };
79521     }
79522   }
79523
79524 }
79525
79526
79527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79528   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79529
79530   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79531   {
79532     try {
79533       (arg1)->Reset();
79534     } catch (std::out_of_range& e) {
79535       {
79536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79537       };
79538     } catch (std::exception& e) {
79539       {
79540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79541       };
79542     } catch (Dali::DaliException e) {
79543       {
79544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79545       };
79546     } catch (...) {
79547       {
79548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79549       };
79550     }
79551   }
79552
79553 }
79554
79555
79556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79557   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79558   Dali::Actor arg2 ;
79559   bool arg3 ;
79560   Dali::Actor *argp2 ;
79561
79562   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79563   argp2 = (Dali::Actor *)jarg2;
79564   if (!argp2) {
79565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79566     return ;
79567   }
79568   arg2 = *argp2;
79569   arg3 = jarg3 ? true : false;
79570   {
79571     try {
79572       (arg1)->SetFocusGroup(arg2,arg3);
79573     } catch (std::out_of_range& e) {
79574       {
79575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79576       };
79577     } catch (std::exception& e) {
79578       {
79579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79580       };
79581     } catch (Dali::DaliException e) {
79582       {
79583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79584       };
79585     } catch (...) {
79586       {
79587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79588       };
79589     }
79590   }
79591
79592 }
79593
79594
79595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79596   unsigned int jresult ;
79597   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79598   Dali::Actor arg2 ;
79599   Dali::Actor *argp2 ;
79600   bool result;
79601
79602   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79603   argp2 = (Dali::Actor *)jarg2;
79604   if (!argp2) {
79605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79606     return 0;
79607   }
79608   arg2 = *argp2;
79609   {
79610     try {
79611       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79612     } catch (std::out_of_range& e) {
79613       {
79614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79615       };
79616     } catch (std::exception& e) {
79617       {
79618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79619       };
79620     } catch (Dali::DaliException e) {
79621       {
79622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79623       };
79624     } catch (...) {
79625       {
79626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79627       };
79628     }
79629   }
79630
79631   jresult = result;
79632   return jresult;
79633 }
79634
79635
79636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79637   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79638   bool arg2 ;
79639
79640   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79641   arg2 = jarg2 ? true : false;
79642   {
79643     try {
79644       (arg1)->SetGroupMode(arg2);
79645     } catch (std::out_of_range& e) {
79646       {
79647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79648       };
79649     } catch (std::exception& e) {
79650       {
79651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79652       };
79653     } catch (Dali::DaliException e) {
79654       {
79655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79656       };
79657     } catch (...) {
79658       {
79659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79660       };
79661     }
79662   }
79663
79664 }
79665
79666
79667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79668   unsigned int jresult ;
79669   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79670   bool result;
79671
79672   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79673   {
79674     try {
79675       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79676     } catch (std::out_of_range& e) {
79677       {
79678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79679       };
79680     } catch (std::exception& e) {
79681       {
79682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79683       };
79684     } catch (Dali::DaliException e) {
79685       {
79686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79687       };
79688     } catch (...) {
79689       {
79690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79691       };
79692     }
79693   }
79694
79695   jresult = result;
79696   return jresult;
79697 }
79698
79699
79700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79701   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79702   bool arg2 ;
79703
79704   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79705   arg2 = jarg2 ? true : false;
79706   {
79707     try {
79708       (arg1)->SetWrapMode(arg2);
79709     } catch (std::out_of_range& e) {
79710       {
79711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79712       };
79713     } catch (std::exception& e) {
79714       {
79715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79716       };
79717     } catch (Dali::DaliException e) {
79718       {
79719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79720       };
79721     } catch (...) {
79722       {
79723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79724       };
79725     }
79726   }
79727
79728 }
79729
79730
79731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79732   unsigned int jresult ;
79733   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79734   bool result;
79735
79736   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79737   {
79738     try {
79739       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79740     } catch (std::out_of_range& e) {
79741       {
79742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79743       };
79744     } catch (std::exception& e) {
79745       {
79746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79747       };
79748     } catch (Dali::DaliException e) {
79749       {
79750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79751       };
79752     } catch (...) {
79753       {
79754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79755       };
79756     }
79757   }
79758
79759   jresult = result;
79760   return jresult;
79761 }
79762
79763
79764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79765   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79766   Dali::Actor arg2 ;
79767   Dali::Actor *argp2 ;
79768
79769   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79770   argp2 = (Dali::Actor *)jarg2;
79771   if (!argp2) {
79772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79773     return ;
79774   }
79775   arg2 = *argp2;
79776   {
79777     try {
79778       (arg1)->SetFocusIndicatorActor(arg2);
79779     } catch (std::out_of_range& e) {
79780       {
79781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79782       };
79783     } catch (std::exception& e) {
79784       {
79785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79786       };
79787     } catch (Dali::DaliException e) {
79788       {
79789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79790       };
79791     } catch (...) {
79792       {
79793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79794       };
79795     }
79796   }
79797
79798 }
79799
79800
79801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79802   void * jresult ;
79803   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79804   Dali::Actor result;
79805
79806   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79807   {
79808     try {
79809       result = (arg1)->GetFocusIndicatorActor();
79810     } catch (std::out_of_range& e) {
79811       {
79812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79813       };
79814     } catch (std::exception& e) {
79815       {
79816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79817       };
79818     } catch (Dali::DaliException e) {
79819       {
79820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79821       };
79822     } catch (...) {
79823       {
79824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79825       };
79826     }
79827   }
79828
79829   jresult = new Dali::Actor((const Dali::Actor &)result);
79830   return jresult;
79831 }
79832
79833
79834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79835   void * jresult ;
79836   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79837   Dali::Actor arg2 ;
79838   Dali::Actor *argp2 ;
79839   Dali::Actor result;
79840
79841   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79842   argp2 = (Dali::Actor *)jarg2;
79843   if (!argp2) {
79844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79845     return 0;
79846   }
79847   arg2 = *argp2;
79848   {
79849     try {
79850       result = (arg1)->GetFocusGroup(arg2);
79851     } catch (std::out_of_range& e) {
79852       {
79853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79854       };
79855     } catch (std::exception& e) {
79856       {
79857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79858       };
79859     } catch (Dali::DaliException e) {
79860       {
79861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79862       };
79863     } catch (...) {
79864       {
79865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79866       };
79867     }
79868   }
79869
79870   jresult = new Dali::Actor((const Dali::Actor &)result);
79871   return jresult;
79872 }
79873
79874
79875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79876   void * jresult ;
79877   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79878   Dali::Vector2 result;
79879
79880   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79881   {
79882     try {
79883       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79884     } catch (std::out_of_range& e) {
79885       {
79886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79887       };
79888     } catch (std::exception& e) {
79889       {
79890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79891       };
79892     } catch (Dali::DaliException e) {
79893       {
79894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79895       };
79896     } catch (...) {
79897       {
79898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79899       };
79900     }
79901   }
79902
79903   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79904   return jresult;
79905 }
79906
79907
79908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79909   void * jresult ;
79910   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79911   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79912
79913   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79914   {
79915     try {
79916       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79917     } catch (std::out_of_range& e) {
79918       {
79919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79920       };
79921     } catch (std::exception& e) {
79922       {
79923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79924       };
79925     } catch (Dali::DaliException e) {
79926       {
79927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79928       };
79929     } catch (...) {
79930       {
79931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79932       };
79933     }
79934   }
79935
79936   jresult = (void *)result;
79937   return jresult;
79938 }
79939
79940
79941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79942   void * jresult ;
79943   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79944   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79945
79946   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79947   {
79948     try {
79949       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79950     } catch (std::out_of_range& e) {
79951       {
79952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79953       };
79954     } catch (std::exception& e) {
79955       {
79956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79957       };
79958     } catch (Dali::DaliException e) {
79959       {
79960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79961       };
79962     } catch (...) {
79963       {
79964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79965       };
79966     }
79967   }
79968
79969   jresult = (void *)result;
79970   return jresult;
79971 }
79972
79973
79974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79975   void * jresult ;
79976   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79977   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79978
79979   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79980   {
79981     try {
79982       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79983     } catch (std::out_of_range& e) {
79984       {
79985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79986       };
79987     } catch (std::exception& e) {
79988       {
79989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79990       };
79991     } catch (Dali::DaliException e) {
79992       {
79993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79994       };
79995     } catch (...) {
79996       {
79997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79998       };
79999     }
80000   }
80001
80002   jresult = (void *)result;
80003   return jresult;
80004 }
80005
80006
80007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80008   void * jresult ;
80009   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80010   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80011
80012   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80013   {
80014     try {
80015       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80016     } catch (std::out_of_range& e) {
80017       {
80018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80019       };
80020     } catch (std::exception& e) {
80021       {
80022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80023       };
80024     } catch (Dali::DaliException e) {
80025       {
80026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80027       };
80028     } catch (...) {
80029       {
80030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80031       };
80032     }
80033   }
80034
80035   jresult = (void *)result;
80036   return jresult;
80037 }
80038
80039
80040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80041   void * jresult ;
80042   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80043   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80044
80045   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80046   {
80047     try {
80048       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80049     } catch (std::out_of_range& e) {
80050       {
80051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80052       };
80053     } catch (std::exception& e) {
80054       {
80055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80056       };
80057     } catch (Dali::DaliException e) {
80058       {
80059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80060       };
80061     } catch (...) {
80062       {
80063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80064       };
80065     }
80066   }
80067
80068   jresult = (void *)result;
80069   return jresult;
80070 }
80071
80072
80073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80074   void * jresult ;
80075   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80076   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80077
80078   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80079   {
80080     try {
80081       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80082     } catch (std::out_of_range& e) {
80083       {
80084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80085       };
80086     } catch (std::exception& e) {
80087       {
80088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80089       };
80090     } catch (Dali::DaliException e) {
80091       {
80092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80093       };
80094     } catch (...) {
80095       {
80096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80097       };
80098     }
80099   }
80100
80101   jresult = (void *)result;
80102   return jresult;
80103 }
80104
80105
80106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80107   void * jresult ;
80108   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80109   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80110
80111   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80112   {
80113     try {
80114       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80115     } catch (std::out_of_range& e) {
80116       {
80117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80118       };
80119     } catch (std::exception& e) {
80120       {
80121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80122       };
80123     } catch (Dali::DaliException e) {
80124       {
80125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80126       };
80127     } catch (...) {
80128       {
80129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80130       };
80131     }
80132   }
80133
80134   jresult = (void *)result;
80135   return jresult;
80136 }
80137
80138
80139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80140   void * jresult ;
80141   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80142   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80143
80144   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80145   {
80146     try {
80147       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80148     } catch (std::out_of_range& e) {
80149       {
80150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80151       };
80152     } catch (std::exception& e) {
80153       {
80154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80155       };
80156     } catch (Dali::DaliException e) {
80157       {
80158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80159       };
80160     } catch (...) {
80161       {
80162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80163       };
80164     }
80165   }
80166
80167   jresult = (void *)result;
80168   return jresult;
80169 }
80170
80171
80172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80173   void * jresult ;
80174   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80175   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80176
80177   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80178   {
80179     try {
80180       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80181     } catch (std::out_of_range& e) {
80182       {
80183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80184       };
80185     } catch (std::exception& e) {
80186       {
80187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80188       };
80189     } catch (Dali::DaliException e) {
80190       {
80191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80192       };
80193     } catch (...) {
80194       {
80195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80196       };
80197     }
80198   }
80199
80200   jresult = (void *)result;
80201   return jresult;
80202 }
80203
80204
80205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80206   void * jresult ;
80207   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80208   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80209
80210   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80211   {
80212     try {
80213       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80214     } catch (std::out_of_range& e) {
80215       {
80216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80217       };
80218     } catch (std::exception& e) {
80219       {
80220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80221       };
80222     } catch (Dali::DaliException e) {
80223       {
80224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80225       };
80226     } catch (...) {
80227       {
80228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80229       };
80230     }
80231   }
80232
80233   jresult = (void *)result;
80234   return jresult;
80235 }
80236
80237
80238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80239   void * jresult ;
80240   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80241   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80242
80243   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80244   {
80245     try {
80246       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80247     } catch (std::out_of_range& e) {
80248       {
80249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80250       };
80251     } catch (std::exception& e) {
80252       {
80253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80254       };
80255     } catch (Dali::DaliException e) {
80256       {
80257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80258       };
80259     } catch (...) {
80260       {
80261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80262       };
80263     }
80264   }
80265
80266   jresult = (void *)result;
80267   return jresult;
80268 }
80269
80270
80271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80272   void * jresult ;
80273   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80274   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80275
80276   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80277   {
80278     try {
80279       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80280     } catch (std::out_of_range& e) {
80281       {
80282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80283       };
80284     } catch (std::exception& e) {
80285       {
80286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80287       };
80288     } catch (Dali::DaliException e) {
80289       {
80290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80291       };
80292     } catch (...) {
80293       {
80294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80295       };
80296     }
80297   }
80298
80299   jresult = (void *)result;
80300   return jresult;
80301 }
80302
80303
80304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80305   void * jresult ;
80306   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80307   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80308
80309   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80310   {
80311     try {
80312       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80313     } catch (std::out_of_range& e) {
80314       {
80315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80316       };
80317     } catch (std::exception& e) {
80318       {
80319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80320       };
80321     } catch (Dali::DaliException e) {
80322       {
80323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80324       };
80325     } catch (...) {
80326       {
80327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80328       };
80329     }
80330   }
80331
80332   jresult = (void *)result;
80333   return jresult;
80334 }
80335
80336
80337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80338   void * jresult ;
80339   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80340   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80341
80342   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80343   {
80344     try {
80345       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80346     } catch (std::out_of_range& e) {
80347       {
80348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80349       };
80350     } catch (std::exception& e) {
80351       {
80352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80353       };
80354     } catch (Dali::DaliException e) {
80355       {
80356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80357       };
80358     } catch (...) {
80359       {
80360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80361       };
80362     }
80363   }
80364
80365   jresult = (void *)result;
80366   return jresult;
80367 }
80368
80369
80370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80371   void * jresult ;
80372   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80373   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80374
80375   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80376   {
80377     try {
80378       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80379     } catch (std::out_of_range& e) {
80380       {
80381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80382       };
80383     } catch (std::exception& e) {
80384       {
80385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80386       };
80387     } catch (Dali::DaliException e) {
80388       {
80389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80390       };
80391     } catch (...) {
80392       {
80393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80394       };
80395     }
80396   }
80397
80398   jresult = (void *)result;
80399   return jresult;
80400 }
80401
80402
80403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80404   void * jresult ;
80405   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80406   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80407
80408   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80409   {
80410     try {
80411       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80412     } catch (std::out_of_range& e) {
80413       {
80414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80415       };
80416     } catch (std::exception& e) {
80417       {
80418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80419       };
80420     } catch (Dali::DaliException e) {
80421       {
80422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80423       };
80424     } catch (...) {
80425       {
80426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80427       };
80428     }
80429   }
80430
80431   jresult = (void *)result;
80432   return jresult;
80433 }
80434
80435
80436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80437   void * jresult ;
80438   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80439   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80440
80441   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80442   {
80443     try {
80444       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80445     } catch (std::out_of_range& e) {
80446       {
80447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80448       };
80449     } catch (std::exception& e) {
80450       {
80451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80452       };
80453     } catch (Dali::DaliException e) {
80454       {
80455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80456       };
80457     } catch (...) {
80458       {
80459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80460       };
80461     }
80462   }
80463
80464   jresult = (void *)result;
80465   return jresult;
80466 }
80467
80468
80469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80470   void * jresult ;
80471   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80472   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80473
80474   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80475   {
80476     try {
80477       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80478     } catch (std::out_of_range& e) {
80479       {
80480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80481       };
80482     } catch (std::exception& e) {
80483       {
80484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80485       };
80486     } catch (Dali::DaliException e) {
80487       {
80488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80489       };
80490     } catch (...) {
80491       {
80492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80493       };
80494     }
80495   }
80496
80497   jresult = (void *)result;
80498   return jresult;
80499 }
80500
80501
80502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80503   void * jresult ;
80504   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80505   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80506
80507   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80508   {
80509     try {
80510       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80511     } catch (std::out_of_range& e) {
80512       {
80513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80514       };
80515     } catch (std::exception& e) {
80516       {
80517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80518       };
80519     } catch (Dali::DaliException e) {
80520       {
80521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80522       };
80523     } catch (...) {
80524       {
80525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80526       };
80527     }
80528   }
80529
80530   jresult = (void *)result;
80531   return jresult;
80532 }
80533
80534
80535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80536   void * jresult ;
80537   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80538   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80539
80540   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80541   {
80542     try {
80543       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80544     } catch (std::out_of_range& e) {
80545       {
80546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80547       };
80548     } catch (std::exception& e) {
80549       {
80550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80551       };
80552     } catch (Dali::DaliException e) {
80553       {
80554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80555       };
80556     } catch (...) {
80557       {
80558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80559       };
80560     }
80561   }
80562
80563   jresult = (void *)result;
80564   return jresult;
80565 }
80566
80567
80568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80569   void * jresult ;
80570   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80571   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80572
80573   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80574   {
80575     try {
80576       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80577     } catch (std::out_of_range& e) {
80578       {
80579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80580       };
80581     } catch (std::exception& e) {
80582       {
80583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80584       };
80585     } catch (Dali::DaliException e) {
80586       {
80587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80588       };
80589     } catch (...) {
80590       {
80591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80592       };
80593     }
80594   }
80595
80596   jresult = (void *)result;
80597   return jresult;
80598 }
80599
80600
80601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80602   void * jresult ;
80603   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80604   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80605
80606   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80607   {
80608     try {
80609       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80610     } catch (std::out_of_range& e) {
80611       {
80612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80613       };
80614     } catch (std::exception& e) {
80615       {
80616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80617       };
80618     } catch (Dali::DaliException e) {
80619       {
80620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80621       };
80622     } catch (...) {
80623       {
80624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80625       };
80626     }
80627   }
80628
80629   jresult = (void *)result;
80630   return jresult;
80631 }
80632
80633
80634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80635   void * jresult ;
80636   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80637   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80638
80639   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80640   {
80641     try {
80642       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80643     } catch (std::out_of_range& e) {
80644       {
80645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80646       };
80647     } catch (std::exception& e) {
80648       {
80649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80650       };
80651     } catch (Dali::DaliException e) {
80652       {
80653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80654       };
80655     } catch (...) {
80656       {
80657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80658       };
80659     }
80660   }
80661
80662   jresult = (void *)result;
80663   return jresult;
80664 }
80665
80666
80667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80668   void * jresult ;
80669   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80670   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80671
80672   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80673   {
80674     try {
80675       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80676     } catch (std::out_of_range& e) {
80677       {
80678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80679       };
80680     } catch (std::exception& e) {
80681       {
80682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80683       };
80684     } catch (Dali::DaliException e) {
80685       {
80686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80687       };
80688     } catch (...) {
80689       {
80690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80691       };
80692     }
80693   }
80694
80695   jresult = (void *)result;
80696   return jresult;
80697 }
80698
80699
80700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80701   void * jresult ;
80702   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80703   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80704
80705   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80706   {
80707     try {
80708       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80709     } catch (std::out_of_range& e) {
80710       {
80711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80712       };
80713     } catch (std::exception& e) {
80714       {
80715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80716       };
80717     } catch (Dali::DaliException e) {
80718       {
80719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80720       };
80721     } catch (...) {
80722       {
80723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80724       };
80725     }
80726   }
80727
80728   jresult = (void *)result;
80729   return jresult;
80730 }
80731
80732
80733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80734   void * jresult ;
80735   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80736   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80737
80738   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80739   {
80740     try {
80741       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80742     } catch (std::out_of_range& e) {
80743       {
80744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80745       };
80746     } catch (std::exception& e) {
80747       {
80748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80749       };
80750     } catch (Dali::DaliException e) {
80751       {
80752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80753       };
80754     } catch (...) {
80755       {
80756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80757       };
80758     }
80759   }
80760
80761   jresult = (void *)result;
80762   return jresult;
80763 }
80764
80765
80766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80767   void * jresult ;
80768   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80769   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80770
80771   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80772   {
80773     try {
80774       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80775     } catch (std::out_of_range& e) {
80776       {
80777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80778       };
80779     } catch (std::exception& e) {
80780       {
80781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80782       };
80783     } catch (Dali::DaliException e) {
80784       {
80785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80786       };
80787     } catch (...) {
80788       {
80789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80790       };
80791     }
80792   }
80793
80794   jresult = (void *)result;
80795   return jresult;
80796 }
80797
80798
80799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80800   void * jresult ;
80801   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80802   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80803
80804   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80805   {
80806     try {
80807       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80808     } catch (std::out_of_range& e) {
80809       {
80810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80811       };
80812     } catch (std::exception& e) {
80813       {
80814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80815       };
80816     } catch (Dali::DaliException e) {
80817       {
80818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80819       };
80820     } catch (...) {
80821       {
80822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80823       };
80824     }
80825   }
80826
80827   jresult = (void *)result;
80828   return jresult;
80829 }
80830
80831
80832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80833   void * jresult ;
80834   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80835   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80836
80837   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80838   {
80839     try {
80840       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80841     } catch (std::out_of_range& e) {
80842       {
80843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80844       };
80845     } catch (std::exception& e) {
80846       {
80847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80848       };
80849     } catch (Dali::DaliException e) {
80850       {
80851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80852       };
80853     } catch (...) {
80854       {
80855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80856       };
80857     }
80858   }
80859
80860   jresult = (void *)result;
80861   return jresult;
80862 }
80863
80864
80865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80866   void * jresult ;
80867   Dali::Toolkit::StyleManager *result = 0 ;
80868
80869   {
80870     try {
80871       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80872     } catch (std::out_of_range& e) {
80873       {
80874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80875       };
80876     } catch (std::exception& e) {
80877       {
80878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80879       };
80880     } catch (Dali::DaliException e) {
80881       {
80882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80883       };
80884     } catch (...) {
80885       {
80886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80887       };
80888     }
80889   }
80890
80891   jresult = (void *)result;
80892   return jresult;
80893 }
80894
80895
80896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80897   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80898
80899   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80900   {
80901     try {
80902       delete arg1;
80903     } catch (std::out_of_range& e) {
80904       {
80905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80906       };
80907     } catch (std::exception& e) {
80908       {
80909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80910       };
80911     } catch (Dali::DaliException e) {
80912       {
80913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80914       };
80915     } catch (...) {
80916       {
80917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80918       };
80919     }
80920   }
80921
80922 }
80923
80924
80925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80926   void * jresult ;
80927   Dali::Toolkit::StyleManager result;
80928
80929   {
80930     try {
80931       result = Dali::Toolkit::StyleManager::Get();
80932     } catch (std::out_of_range& e) {
80933       {
80934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80935       };
80936     } catch (std::exception& e) {
80937       {
80938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80939       };
80940     } catch (Dali::DaliException e) {
80941       {
80942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80943       };
80944     } catch (...) {
80945       {
80946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80947       };
80948     }
80949   }
80950
80951   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80952   return jresult;
80953 }
80954
80955
80956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80957   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80958   std::string *arg2 = 0 ;
80959
80960   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80961   if (!jarg2) {
80962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80963     return ;
80964   }
80965   std::string arg2_str(jarg2);
80966   arg2 = &arg2_str;
80967   {
80968     try {
80969       (arg1)->ApplyTheme((std::string const &)*arg2);
80970     } catch (std::out_of_range& e) {
80971       {
80972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80973       };
80974     } catch (std::exception& e) {
80975       {
80976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80977       };
80978     } catch (Dali::DaliException e) {
80979       {
80980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80981       };
80982     } catch (...) {
80983       {
80984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80985       };
80986     }
80987   }
80988
80989
80990   //argout typemap for const std::string&
80991
80992 }
80993
80994
80995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80996   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80997
80998   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80999   {
81000     try {
81001       (arg1)->ApplyDefaultTheme();
81002     } catch (std::out_of_range& e) {
81003       {
81004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81005       };
81006     } catch (std::exception& e) {
81007       {
81008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81009       };
81010     } catch (Dali::DaliException e) {
81011       {
81012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81013       };
81014     } catch (...) {
81015       {
81016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81017       };
81018     }
81019   }
81020
81021 }
81022
81023
81024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81025   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81026   std::string *arg2 = 0 ;
81027   Dali::Property::Value *arg3 = 0 ;
81028
81029   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81030   if (!jarg2) {
81031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81032     return ;
81033   }
81034   std::string arg2_str(jarg2);
81035   arg2 = &arg2_str;
81036   arg3 = (Dali::Property::Value *)jarg3;
81037   if (!arg3) {
81038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81039     return ;
81040   }
81041   {
81042     try {
81043       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81044     } catch (std::out_of_range& e) {
81045       {
81046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81047       };
81048     } catch (std::exception& e) {
81049       {
81050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81051       };
81052     } catch (Dali::DaliException e) {
81053       {
81054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81055       };
81056     } catch (...) {
81057       {
81058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81059       };
81060     }
81061   }
81062
81063
81064   //argout typemap for const std::string&
81065
81066 }
81067
81068
81069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81070   unsigned int jresult ;
81071   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81072   std::string *arg2 = 0 ;
81073   Dali::Property::Value *arg3 = 0 ;
81074   bool result;
81075
81076   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81077   if (!jarg2) {
81078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81079     return 0;
81080   }
81081   std::string arg2_str(jarg2);
81082   arg2 = &arg2_str;
81083   arg3 = (Dali::Property::Value *)jarg3;
81084   if (!arg3) {
81085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81086     return 0;
81087   }
81088   {
81089     try {
81090       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81091     } catch (std::out_of_range& e) {
81092       {
81093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81094       };
81095     } catch (std::exception& e) {
81096       {
81097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81098       };
81099     } catch (Dali::DaliException e) {
81100       {
81101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81102       };
81103     } catch (...) {
81104       {
81105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81106       };
81107     }
81108   }
81109
81110   jresult = result;
81111
81112   //argout typemap for const std::string&
81113
81114   return jresult;
81115 }
81116
81117
81118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81119   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81120   Dali::Toolkit::Control arg2 ;
81121   std::string *arg3 = 0 ;
81122   std::string *arg4 = 0 ;
81123   Dali::Toolkit::Control *argp2 ;
81124
81125   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81126   argp2 = (Dali::Toolkit::Control *)jarg2;
81127   if (!argp2) {
81128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81129     return ;
81130   }
81131   arg2 = *argp2;
81132   if (!jarg3) {
81133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81134     return ;
81135   }
81136   std::string arg3_str(jarg3);
81137   arg3 = &arg3_str;
81138   if (!jarg4) {
81139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81140     return ;
81141   }
81142   std::string arg4_str(jarg4);
81143   arg4 = &arg4_str;
81144   {
81145     try {
81146       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81147     } catch (std::out_of_range& e) {
81148       {
81149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81150       };
81151     } catch (std::exception& e) {
81152       {
81153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81154       };
81155     } catch (Dali::DaliException e) {
81156       {
81157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81158       };
81159     } catch (...) {
81160       {
81161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81162       };
81163     }
81164   }
81165
81166
81167   //argout typemap for const std::string&
81168
81169
81170   //argout typemap for const std::string&
81171
81172 }
81173
81174
81175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81176   void * jresult ;
81177   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81178   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81179
81180   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81181   {
81182     try {
81183       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81184     } catch (std::out_of_range& e) {
81185       {
81186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81187       };
81188     } catch (std::exception& e) {
81189       {
81190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81191       };
81192     } catch (Dali::DaliException e) {
81193       {
81194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81195       };
81196     } catch (...) {
81197       {
81198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81199       };
81200     }
81201   }
81202
81203   jresult = (void *)result;
81204   return jresult;
81205 }
81206
81207
81208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81209   int jresult ;
81210   int result;
81211
81212   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81213   jresult = (int)result;
81214   return jresult;
81215 }
81216
81217
81218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81219   int jresult ;
81220   int result;
81221
81222   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81223   jresult = (int)result;
81224   return jresult;
81225 }
81226
81227
81228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81229   int jresult ;
81230   int result;
81231
81232   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81233   jresult = (int)result;
81234   return jresult;
81235 }
81236
81237
81238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81239   int jresult ;
81240   int result;
81241
81242   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81243   jresult = (int)result;
81244   return jresult;
81245 }
81246
81247
81248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81249   int jresult ;
81250   int result;
81251
81252   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81253   jresult = (int)result;
81254   return jresult;
81255 }
81256
81257
81258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81259   int jresult ;
81260   int result;
81261
81262   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81263   jresult = (int)result;
81264   return jresult;
81265 }
81266
81267
81268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81269   int jresult ;
81270   int result;
81271
81272   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81273   jresult = (int)result;
81274   return jresult;
81275 }
81276
81277
81278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81279   int jresult ;
81280   int result;
81281
81282   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81283   jresult = (int)result;
81284   return jresult;
81285 }
81286
81287
81288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81289   int jresult ;
81290   int result;
81291
81292   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81293   jresult = (int)result;
81294   return jresult;
81295 }
81296
81297
81298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81299   int jresult ;
81300   int result;
81301
81302   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81303   jresult = (int)result;
81304   return jresult;
81305 }
81306
81307
81308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81309   int jresult ;
81310   int result;
81311
81312   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81313   jresult = (int)result;
81314   return jresult;
81315 }
81316
81317
81318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81319   int jresult ;
81320   int result;
81321
81322   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81323   jresult = (int)result;
81324   return jresult;
81325 }
81326
81327
81328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81329   int jresult ;
81330   int result;
81331
81332   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81333   jresult = (int)result;
81334   return jresult;
81335 }
81336
81337
81338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81339   int jresult ;
81340   int result;
81341
81342   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81343   jresult = (int)result;
81344   return jresult;
81345 }
81346
81347
81348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81349   int jresult ;
81350   int result;
81351
81352   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81353   jresult = (int)result;
81354   return jresult;
81355 }
81356
81357
81358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81359   void * jresult ;
81360   Dali::Toolkit::Slider::Property *result = 0 ;
81361
81362   {
81363     try {
81364       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81365     } catch (std::out_of_range& e) {
81366       {
81367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81368       };
81369     } catch (std::exception& e) {
81370       {
81371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81372       };
81373     } catch (Dali::DaliException e) {
81374       {
81375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81376       };
81377     } catch (...) {
81378       {
81379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81380       };
81381     }
81382   }
81383
81384   jresult = (void *)result;
81385   return jresult;
81386 }
81387
81388
81389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81390   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81391
81392   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81393   {
81394     try {
81395       delete arg1;
81396     } catch (std::out_of_range& e) {
81397       {
81398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81399       };
81400     } catch (std::exception& e) {
81401       {
81402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81403       };
81404     } catch (Dali::DaliException e) {
81405       {
81406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81407       };
81408     } catch (...) {
81409       {
81410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81411       };
81412     }
81413   }
81414
81415 }
81416
81417
81418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81419   void * jresult ;
81420   Dali::Toolkit::Slider result;
81421
81422   {
81423     try {
81424       result = Dali::Toolkit::Slider::New();
81425     } catch (std::out_of_range& e) {
81426       {
81427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81428       };
81429     } catch (std::exception& e) {
81430       {
81431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81432       };
81433     } catch (Dali::DaliException e) {
81434       {
81435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81436       };
81437     } catch (...) {
81438       {
81439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81440       };
81441     }
81442   }
81443
81444   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81445   return jresult;
81446 }
81447
81448
81449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81450   void * jresult ;
81451   Dali::Toolkit::Slider *result = 0 ;
81452
81453   {
81454     try {
81455       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81456     } catch (std::out_of_range& e) {
81457       {
81458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81459       };
81460     } catch (std::exception& e) {
81461       {
81462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81463       };
81464     } catch (Dali::DaliException e) {
81465       {
81466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81467       };
81468     } catch (...) {
81469       {
81470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81471       };
81472     }
81473   }
81474
81475   jresult = (void *)result;
81476   return jresult;
81477 }
81478
81479
81480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81481   void * jresult ;
81482   Dali::Toolkit::Slider *arg1 = 0 ;
81483   Dali::Toolkit::Slider *result = 0 ;
81484
81485   arg1 = (Dali::Toolkit::Slider *)jarg1;
81486   if (!arg1) {
81487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81488     return 0;
81489   }
81490   {
81491     try {
81492       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81493     } catch (std::out_of_range& e) {
81494       {
81495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81496       };
81497     } catch (std::exception& e) {
81498       {
81499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81500       };
81501     } catch (Dali::DaliException e) {
81502       {
81503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81504       };
81505     } catch (...) {
81506       {
81507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81508       };
81509     }
81510   }
81511
81512   jresult = (void *)result;
81513   return jresult;
81514 }
81515
81516
81517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81518   void * jresult ;
81519   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81520   Dali::Toolkit::Slider *arg2 = 0 ;
81521   Dali::Toolkit::Slider *result = 0 ;
81522
81523   arg1 = (Dali::Toolkit::Slider *)jarg1;
81524   arg2 = (Dali::Toolkit::Slider *)jarg2;
81525   if (!arg2) {
81526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81527     return 0;
81528   }
81529   {
81530     try {
81531       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81532     } catch (std::out_of_range& e) {
81533       {
81534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81535       };
81536     } catch (std::exception& e) {
81537       {
81538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81539       };
81540     } catch (Dali::DaliException e) {
81541       {
81542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81543       };
81544     } catch (...) {
81545       {
81546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81547       };
81548     }
81549   }
81550
81551   jresult = (void *)result;
81552   return jresult;
81553 }
81554
81555
81556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81557   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81558
81559   arg1 = (Dali::Toolkit::Slider *)jarg1;
81560   {
81561     try {
81562       delete arg1;
81563     } catch (std::out_of_range& e) {
81564       {
81565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81566       };
81567     } catch (std::exception& e) {
81568       {
81569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81570       };
81571     } catch (Dali::DaliException e) {
81572       {
81573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81574       };
81575     } catch (...) {
81576       {
81577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81578       };
81579     }
81580   }
81581
81582 }
81583
81584
81585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81586   void * jresult ;
81587   Dali::BaseHandle arg1 ;
81588   Dali::BaseHandle *argp1 ;
81589   Dali::Toolkit::Slider result;
81590
81591   argp1 = (Dali::BaseHandle *)jarg1;
81592   if (!argp1) {
81593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81594     return 0;
81595   }
81596   arg1 = *argp1;
81597   {
81598     try {
81599       result = Dali::Toolkit::Slider::DownCast(arg1);
81600     } catch (std::out_of_range& e) {
81601       {
81602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81603       };
81604     } catch (std::exception& e) {
81605       {
81606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81607       };
81608     } catch (Dali::DaliException e) {
81609       {
81610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81611       };
81612     } catch (...) {
81613       {
81614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81615       };
81616     }
81617   }
81618
81619   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81620   return jresult;
81621 }
81622
81623
81624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81625   void * jresult ;
81626   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81627   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81628
81629   arg1 = (Dali::Toolkit::Slider *)jarg1;
81630   {
81631     try {
81632       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81633     } catch (std::out_of_range& e) {
81634       {
81635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81636       };
81637     } catch (std::exception& e) {
81638       {
81639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81640       };
81641     } catch (Dali::DaliException e) {
81642       {
81643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81644       };
81645     } catch (...) {
81646       {
81647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81648       };
81649     }
81650   }
81651
81652   jresult = (void *)result;
81653   return jresult;
81654 }
81655
81656
81657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81658   void * jresult ;
81659   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81660   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81661
81662   arg1 = (Dali::Toolkit::Slider *)jarg1;
81663   {
81664     try {
81665       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81666     } catch (std::out_of_range& e) {
81667       {
81668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81669       };
81670     } catch (std::exception& e) {
81671       {
81672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81673       };
81674     } catch (Dali::DaliException e) {
81675       {
81676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81677       };
81678     } catch (...) {
81679       {
81680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81681       };
81682     }
81683   }
81684
81685   jresult = (void *)result;
81686   return jresult;
81687 }
81688
81689
81690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81691   void * jresult ;
81692   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81693   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81694
81695   arg1 = (Dali::Toolkit::Slider *)jarg1;
81696   {
81697     try {
81698       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81699     } catch (std::out_of_range& e) {
81700       {
81701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81702       };
81703     } catch (std::exception& e) {
81704       {
81705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81706       };
81707     } catch (Dali::DaliException e) {
81708       {
81709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81710       };
81711     } catch (...) {
81712       {
81713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81714       };
81715     }
81716   }
81717
81718   jresult = (void *)result;
81719   return jresult;
81720 }
81721
81722
81723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81724   int jresult ;
81725   int result;
81726
81727   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81728   jresult = (int)result;
81729   return jresult;
81730 }
81731
81732
81733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81734   int jresult ;
81735   int result;
81736
81737   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81738   jresult = (int)result;
81739   return jresult;
81740 }
81741
81742
81743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81744   int jresult ;
81745   int result;
81746
81747   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81748   jresult = (int)result;
81749   return jresult;
81750 }
81751
81752
81753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81754   int jresult ;
81755   int result;
81756
81757   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81758   jresult = (int)result;
81759   return jresult;
81760 }
81761
81762
81763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
81764   int result;
81765
81766   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
81767
81768   return result;
81769 }
81770
81771
81772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81773   void * jresult ;
81774   Dali::Toolkit::VideoView::Property *result = 0 ;
81775
81776   {
81777     try {
81778       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81779     } catch (std::out_of_range& e) {
81780       {
81781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81782       };
81783     } catch (std::exception& e) {
81784       {
81785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81786       };
81787     } catch (Dali::DaliException e) {
81788       {
81789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81790       };
81791     } catch (...) {
81792       {
81793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81794       };
81795     }
81796   }
81797
81798   jresult = (void *)result;
81799   return jresult;
81800 }
81801
81802
81803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81804   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81805
81806   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81807   {
81808     try {
81809       delete arg1;
81810     } catch (std::out_of_range& e) {
81811       {
81812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81813       };
81814     } catch (std::exception& e) {
81815       {
81816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81817       };
81818     } catch (Dali::DaliException e) {
81819       {
81820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81821       };
81822     } catch (...) {
81823       {
81824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81825       };
81826     }
81827   }
81828
81829 }
81830
81831
81832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81833   void * jresult ;
81834   Dali::Toolkit::VideoView result;
81835
81836   {
81837     try {
81838       result = Dali::Toolkit::VideoView::New();
81839     } catch (std::out_of_range& e) {
81840       {
81841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81842       };
81843     } catch (std::exception& e) {
81844       {
81845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81846       };
81847     } catch (Dali::DaliException e) {
81848       {
81849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81850       };
81851     } catch (...) {
81852       {
81853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81854       };
81855     }
81856   }
81857
81858   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81859   return jresult;
81860 }
81861
81862
81863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81864   void * jresult ;
81865   std::string *arg1 = 0 ;
81866   Dali::Toolkit::VideoView result;
81867
81868   if (!jarg1) {
81869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81870     return 0;
81871   }
81872   std::string arg1_str(jarg1);
81873   arg1 = &arg1_str;
81874   {
81875     try {
81876       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81877     } catch (std::out_of_range& e) {
81878       {
81879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81880       };
81881     } catch (std::exception& e) {
81882       {
81883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81884       };
81885     } catch (Dali::DaliException e) {
81886       {
81887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81888       };
81889     } catch (...) {
81890       {
81891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81892       };
81893     }
81894   }
81895
81896   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81897
81898   //argout typemap for const std::string&
81899
81900   return jresult;
81901 }
81902
81903
81904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
81905   void * jresult ;
81906   Dali::Toolkit::VideoView result;
81907   {
81908     try {
81909       result = Dali::Toolkit::VideoView::New(swCodec);
81910     } catch (std::out_of_range& e) {
81911       {
81912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81913       };
81914     } catch (std::exception& e) {
81915       {
81916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81917       };
81918     } catch (Dali::DaliException e) {
81919       {
81920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81921       };
81922     } catch (...) {
81923       {
81924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81925       };
81926     }
81927   }
81928
81929   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81930
81931   //argout typemap for const std::string&
81932
81933   return jresult;
81934 }
81935
81936
81937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
81938   void * jresult ;
81939   std::string *arg1 = 0 ;
81940   Dali::Toolkit::VideoView result;
81941
81942   if (!jarg1) {
81943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81944     return 0;
81945   }
81946   std::string arg1_str(jarg1);
81947   arg1 = &arg1_str;
81948   {
81949     try {
81950       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
81951     } catch (std::out_of_range& e) {
81952       {
81953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81954       };
81955     } catch (std::exception& e) {
81956       {
81957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81958       };
81959     } catch (Dali::DaliException e) {
81960       {
81961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81962       };
81963     } catch (...) {
81964       {
81965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81966       };
81967     }
81968   }
81969
81970   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81971
81972   //argout typemap for const std::string&
81973
81974   return jresult;
81975 }
81976
81977
81978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81979   void * jresult ;
81980   Dali::Toolkit::VideoView *result = 0 ;
81981
81982   {
81983     try {
81984       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81985     } catch (std::out_of_range& e) {
81986       {
81987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81988       };
81989     } catch (std::exception& e) {
81990       {
81991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81992       };
81993     } catch (Dali::DaliException e) {
81994       {
81995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81996       };
81997     } catch (...) {
81998       {
81999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82000       };
82001     }
82002   }
82003
82004   jresult = (void *)result;
82005   return jresult;
82006 }
82007
82008
82009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82010   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82011
82012   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82013   {
82014     try {
82015       delete arg1;
82016     } catch (std::out_of_range& e) {
82017       {
82018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82019       };
82020     } catch (std::exception& e) {
82021       {
82022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82023       };
82024     } catch (Dali::DaliException e) {
82025       {
82026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82027       };
82028     } catch (...) {
82029       {
82030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82031       };
82032     }
82033   }
82034
82035 }
82036
82037
82038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82039   void * jresult ;
82040   Dali::Toolkit::VideoView *arg1 = 0 ;
82041   Dali::Toolkit::VideoView *result = 0 ;
82042
82043   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82044   if (!arg1) {
82045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82046     return 0;
82047   }
82048   {
82049     try {
82050       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82051     } catch (std::out_of_range& e) {
82052       {
82053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82054       };
82055     } catch (std::exception& e) {
82056       {
82057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82058       };
82059     } catch (Dali::DaliException e) {
82060       {
82061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82062       };
82063     } catch (...) {
82064       {
82065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82066       };
82067     }
82068   }
82069
82070   jresult = (void *)result;
82071   return jresult;
82072 }
82073
82074
82075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82076   void * jresult ;
82077   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82078   Dali::Toolkit::VideoView *arg2 = 0 ;
82079   Dali::Toolkit::VideoView *result = 0 ;
82080
82081   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82082   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82083   if (!arg2) {
82084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82085     return 0;
82086   }
82087   {
82088     try {
82089       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82090     } catch (std::out_of_range& e) {
82091       {
82092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82093       };
82094     } catch (std::exception& e) {
82095       {
82096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82097       };
82098     } catch (Dali::DaliException e) {
82099       {
82100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82101       };
82102     } catch (...) {
82103       {
82104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82105       };
82106     }
82107   }
82108
82109   jresult = (void *)result;
82110   return jresult;
82111 }
82112
82113
82114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82115   void * jresult ;
82116   Dali::BaseHandle arg1 ;
82117   Dali::BaseHandle *argp1 ;
82118   Dali::Toolkit::VideoView result;
82119
82120   argp1 = (Dali::BaseHandle *)jarg1;
82121   if (!argp1) {
82122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82123     return 0;
82124   }
82125   arg1 = *argp1;
82126   {
82127     try {
82128       result = Dali::Toolkit::VideoView::DownCast(arg1);
82129     } catch (std::out_of_range& e) {
82130       {
82131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82132       };
82133     } catch (std::exception& e) {
82134       {
82135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82136       };
82137     } catch (Dali::DaliException e) {
82138       {
82139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82140       };
82141     } catch (...) {
82142       {
82143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82144       };
82145     }
82146   }
82147
82148   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82149   return jresult;
82150 }
82151
82152
82153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82154   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82155
82156   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82157   {
82158     try {
82159       (arg1)->Play();
82160     } catch (std::out_of_range& e) {
82161       {
82162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82163       };
82164     } catch (std::exception& e) {
82165       {
82166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82167       };
82168     } catch (Dali::DaliException e) {
82169       {
82170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82171       };
82172     } catch (...) {
82173       {
82174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82175       };
82176     }
82177   }
82178
82179 }
82180
82181
82182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82183   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82184
82185   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82186   {
82187     try {
82188       (arg1)->Pause();
82189     } catch (std::out_of_range& e) {
82190       {
82191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82192       };
82193     } catch (std::exception& e) {
82194       {
82195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82196       };
82197     } catch (Dali::DaliException e) {
82198       {
82199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82200       };
82201     } catch (...) {
82202       {
82203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82204       };
82205     }
82206   }
82207
82208 }
82209
82210
82211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82212   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82213
82214   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82215   {
82216     try {
82217       (arg1)->Stop();
82218     } catch (std::out_of_range& e) {
82219       {
82220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82221       };
82222     } catch (std::exception& e) {
82223       {
82224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82225       };
82226     } catch (Dali::DaliException e) {
82227       {
82228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82229       };
82230     } catch (...) {
82231       {
82232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82233       };
82234     }
82235   }
82236
82237 }
82238
82239
82240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82241   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82242   int arg2 ;
82243
82244   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82245   arg2 = (int)jarg2;
82246   {
82247     try {
82248       (arg1)->Forward(arg2);
82249     } catch (std::out_of_range& e) {
82250       {
82251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82252       };
82253     } catch (std::exception& e) {
82254       {
82255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82256       };
82257     } catch (Dali::DaliException e) {
82258       {
82259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82260       };
82261     } catch (...) {
82262       {
82263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82264       };
82265     }
82266   }
82267
82268 }
82269
82270
82271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82272   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82273   int arg2 ;
82274
82275   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82276   arg2 = (int)jarg2;
82277   {
82278     try {
82279       (arg1)->Backward(arg2);
82280     } catch (std::out_of_range& e) {
82281       {
82282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82283       };
82284     } catch (std::exception& e) {
82285       {
82286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82287       };
82288     } catch (Dali::DaliException e) {
82289       {
82290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82291       };
82292     } catch (...) {
82293       {
82294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82295       };
82296     }
82297   }
82298
82299 }
82300
82301
82302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82303   void * jresult ;
82304   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82305   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82306
82307   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82308   {
82309     try {
82310       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82311     } catch (std::out_of_range& e) {
82312       {
82313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82314       };
82315     } catch (std::exception& e) {
82316       {
82317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82318       };
82319     } catch (Dali::DaliException e) {
82320       {
82321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82322       };
82323     } catch (...) {
82324       {
82325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82326       };
82327     }
82328   }
82329
82330   jresult = (void *)result;
82331   return jresult;
82332 }
82333
82334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82335 {
82336   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82337   if( arg1 == nullptr )
82338   {
82339     DALI_LOG_ERROR("VideoView is nullptr!");
82340     return nullptr;
82341   }
82342   void * ret = nullptr;
82343   {
82344     try{
82345
82346       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82347       ret = Dali::AnyCast< void * >( result );
82348
82349     } catch (std::out_of_range& e) {
82350       {
82351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82352       };
82353     } catch (std::exception& e) {
82354       {
82355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82356       };
82357     } catch (Dali::DaliException e) {
82358       {
82359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82360       };
82361     } catch (...) {
82362       {
82363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82364       };
82365     }
82366   }
82367   return ret;
82368 }
82369
82370
82371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82372   int jresult ;
82373   int result;
82374
82375   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82376   jresult = (int)result;
82377   return jresult;
82378 }
82379
82380
82381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82382   int jresult ;
82383   int result;
82384
82385   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82386   jresult = (int)result;
82387   return jresult;
82388 }
82389
82390
82391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82392   int jresult ;
82393   int result;
82394
82395   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82396   jresult = (int)result;
82397   return jresult;
82398 }
82399
82400
82401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82402   int jresult ;
82403   int result;
82404
82405   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82406   jresult = (int)result;
82407   return jresult;
82408 }
82409
82410
82411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82412   int jresult ;
82413   int result;
82414
82415   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82416   jresult = (int)result;
82417   return jresult;
82418 }
82419
82420
82421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82422   int jresult ;
82423   int result;
82424
82425   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82426   jresult = (int)result;
82427   return jresult;
82428 }
82429
82430
82431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82432   int jresult ;
82433   int result;
82434
82435   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82436   jresult = (int)result;
82437   return jresult;
82438 }
82439
82440
82441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82442   int jresult ;
82443   int result;
82444
82445   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82446   jresult = (int)result;
82447   return jresult;
82448 }
82449
82450
82451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82452   int jresult ;
82453   int result;
82454
82455   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82456   jresult = (int)result;
82457   return jresult;
82458 }
82459
82460
82461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82462   int jresult ;
82463   int result;
82464
82465   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82466   jresult = (int)result;
82467   return jresult;
82468 }
82469
82470
82471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82472   int jresult ;
82473   int result;
82474
82475   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82476   jresult = (int)result;
82477   return jresult;
82478 }
82479
82480
82481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82482   int jresult ;
82483   int result;
82484
82485   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82486   jresult = (int)result;
82487   return jresult;
82488 }
82489
82490
82491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82492   int jresult ;
82493   int result;
82494
82495   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82496   jresult = (int)result;
82497   return jresult;
82498 }
82499
82500
82501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82502   int jresult ;
82503   int result;
82504
82505   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82506   jresult = (int)result;
82507   return jresult;
82508 }
82509
82510
82511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82512   int jresult ;
82513   int result;
82514
82515   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82516   jresult = (int)result;
82517   return jresult;
82518 }
82519
82520
82521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82522   int jresult ;
82523   int result;
82524
82525   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82526   jresult = (int)result;
82527   return jresult;
82528 }
82529
82530
82531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82532   int jresult ;
82533   int result;
82534
82535   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82536   jresult = (int)result;
82537   return jresult;
82538 }
82539
82540
82541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82542   int jresult ;
82543   int result;
82544
82545   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82546   jresult = (int)result;
82547   return jresult;
82548 }
82549
82550
82551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82552   int jresult ;
82553   int result;
82554
82555   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82556   jresult = (int)result;
82557   return jresult;
82558 }
82559
82560
82561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82562   int jresult ;
82563   int result;
82564
82565   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82566   jresult = (int)result;
82567   return jresult;
82568 }
82569
82570
82571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82572   int jresult ;
82573   int result;
82574
82575   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82576   jresult = (int)result;
82577   return jresult;
82578 }
82579
82580
82581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82582   void * jresult ;
82583   Dali::Toolkit::Popup::Property *result = 0 ;
82584
82585   {
82586     try {
82587       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82588     } catch (std::out_of_range& e) {
82589       {
82590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82591       };
82592     } catch (std::exception& e) {
82593       {
82594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82595       };
82596     } catch (Dali::DaliException e) {
82597       {
82598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82599       };
82600     } catch (...) {
82601       {
82602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82603       };
82604     }
82605   }
82606
82607   jresult = (void *)result;
82608   return jresult;
82609 }
82610
82611
82612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82613   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82614
82615   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82616   {
82617     try {
82618       delete arg1;
82619     } catch (std::out_of_range& e) {
82620       {
82621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82622       };
82623     } catch (std::exception& e) {
82624       {
82625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82626       };
82627     } catch (Dali::DaliException e) {
82628       {
82629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82630       };
82631     } catch (...) {
82632       {
82633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82634       };
82635     }
82636   }
82637
82638 }
82639
82640
82641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82642   void * jresult ;
82643   Dali::Toolkit::Popup *result = 0 ;
82644
82645   {
82646     try {
82647       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82648     } catch (std::out_of_range& e) {
82649       {
82650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82651       };
82652     } catch (std::exception& e) {
82653       {
82654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82655       };
82656     } catch (Dali::DaliException e) {
82657       {
82658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82659       };
82660     } catch (...) {
82661       {
82662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82663       };
82664     }
82665   }
82666
82667   jresult = (void *)result;
82668   return jresult;
82669 }
82670
82671
82672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82673   void * jresult ;
82674   Dali::Toolkit::Popup result;
82675
82676   {
82677     try {
82678       result = Dali::Toolkit::Popup::New();
82679     } catch (std::out_of_range& e) {
82680       {
82681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82682       };
82683     } catch (std::exception& e) {
82684       {
82685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82686       };
82687     } catch (Dali::DaliException e) {
82688       {
82689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82690       };
82691     } catch (...) {
82692       {
82693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82694       };
82695     }
82696   }
82697
82698   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82699   return jresult;
82700 }
82701
82702
82703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82704   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82705
82706   arg1 = (Dali::Toolkit::Popup *)jarg1;
82707   {
82708     try {
82709       delete arg1;
82710     } catch (std::out_of_range& e) {
82711       {
82712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82713       };
82714     } catch (std::exception& e) {
82715       {
82716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82717       };
82718     } catch (Dali::DaliException e) {
82719       {
82720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82721       };
82722     } catch (...) {
82723       {
82724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82725       };
82726     }
82727   }
82728
82729 }
82730
82731
82732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82733   void * jresult ;
82734   Dali::Toolkit::Popup *arg1 = 0 ;
82735   Dali::Toolkit::Popup *result = 0 ;
82736
82737   arg1 = (Dali::Toolkit::Popup *)jarg1;
82738   if (!arg1) {
82739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82740     return 0;
82741   }
82742   {
82743     try {
82744       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82745     } catch (std::out_of_range& e) {
82746       {
82747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82748       };
82749     } catch (std::exception& e) {
82750       {
82751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82752       };
82753     } catch (Dali::DaliException e) {
82754       {
82755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82756       };
82757     } catch (...) {
82758       {
82759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82760       };
82761     }
82762   }
82763
82764   jresult = (void *)result;
82765   return jresult;
82766 }
82767
82768
82769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82770   void * jresult ;
82771   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82772   Dali::Toolkit::Popup *arg2 = 0 ;
82773   Dali::Toolkit::Popup *result = 0 ;
82774
82775   arg1 = (Dali::Toolkit::Popup *)jarg1;
82776   arg2 = (Dali::Toolkit::Popup *)jarg2;
82777   if (!arg2) {
82778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82779     return 0;
82780   }
82781   {
82782     try {
82783       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82784     } catch (std::out_of_range& e) {
82785       {
82786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82787       };
82788     } catch (std::exception& e) {
82789       {
82790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82791       };
82792     } catch (Dali::DaliException e) {
82793       {
82794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82795       };
82796     } catch (...) {
82797       {
82798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82799       };
82800     }
82801   }
82802
82803   jresult = (void *)result;
82804   return jresult;
82805 }
82806
82807
82808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82809   void * jresult ;
82810   Dali::BaseHandle arg1 ;
82811   Dali::BaseHandle *argp1 ;
82812   Dali::Toolkit::Popup result;
82813
82814   argp1 = (Dali::BaseHandle *)jarg1;
82815   if (!argp1) {
82816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82817     return 0;
82818   }
82819   arg1 = *argp1;
82820   {
82821     try {
82822       result = Dali::Toolkit::Popup::DownCast(arg1);
82823     } catch (std::out_of_range& e) {
82824       {
82825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82826       };
82827     } catch (std::exception& e) {
82828       {
82829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82830       };
82831     } catch (Dali::DaliException e) {
82832       {
82833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82834       };
82835     } catch (...) {
82836       {
82837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82838       };
82839     }
82840   }
82841
82842   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82843   return jresult;
82844 }
82845
82846
82847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82848   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82849   Dali::Actor arg2 ;
82850   Dali::Actor *argp2 ;
82851
82852   arg1 = (Dali::Toolkit::Popup *)jarg1;
82853   argp2 = (Dali::Actor *)jarg2;
82854   if (!argp2) {
82855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82856     return ;
82857   }
82858   arg2 = *argp2;
82859   {
82860     try {
82861       (arg1)->SetTitle(arg2);
82862     } catch (std::out_of_range& e) {
82863       {
82864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82865       };
82866     } catch (std::exception& e) {
82867       {
82868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82869       };
82870     } catch (Dali::DaliException e) {
82871       {
82872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82873       };
82874     } catch (...) {
82875       {
82876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82877       };
82878     }
82879   }
82880
82881 }
82882
82883
82884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82885   void * jresult ;
82886   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82887   Dali::Actor result;
82888
82889   arg1 = (Dali::Toolkit::Popup *)jarg1;
82890   {
82891     try {
82892       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82893     } catch (std::out_of_range& e) {
82894       {
82895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82896       };
82897     } catch (std::exception& e) {
82898       {
82899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82900       };
82901     } catch (Dali::DaliException e) {
82902       {
82903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82904       };
82905     } catch (...) {
82906       {
82907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82908       };
82909     }
82910   }
82911
82912   jresult = new Dali::Actor((const Dali::Actor &)result);
82913   return jresult;
82914 }
82915
82916
82917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82918   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82919   Dali::Actor arg2 ;
82920   Dali::Actor *argp2 ;
82921
82922   arg1 = (Dali::Toolkit::Popup *)jarg1;
82923   argp2 = (Dali::Actor *)jarg2;
82924   if (!argp2) {
82925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82926     return ;
82927   }
82928   arg2 = *argp2;
82929   {
82930     try {
82931       (arg1)->SetContent(arg2);
82932     } catch (std::out_of_range& e) {
82933       {
82934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82935       };
82936     } catch (std::exception& e) {
82937       {
82938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82939       };
82940     } catch (Dali::DaliException e) {
82941       {
82942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82943       };
82944     } catch (...) {
82945       {
82946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82947       };
82948     }
82949   }
82950
82951 }
82952
82953
82954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
82955   void * jresult ;
82956   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82957   Dali::Actor result;
82958
82959   arg1 = (Dali::Toolkit::Popup *)jarg1;
82960   {
82961     try {
82962       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82963     } catch (std::out_of_range& e) {
82964       {
82965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82966       };
82967     } catch (std::exception& e) {
82968       {
82969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82970       };
82971     } catch (Dali::DaliException e) {
82972       {
82973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82974       };
82975     } catch (...) {
82976       {
82977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82978       };
82979     }
82980   }
82981
82982   jresult = new Dali::Actor((const Dali::Actor &)result);
82983   return jresult;
82984 }
82985
82986
82987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82988   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82989   Dali::Actor arg2 ;
82990   Dali::Actor *argp2 ;
82991
82992   arg1 = (Dali::Toolkit::Popup *)jarg1;
82993   argp2 = (Dali::Actor *)jarg2;
82994   if (!argp2) {
82995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82996     return ;
82997   }
82998   arg2 = *argp2;
82999   {
83000     try {
83001       (arg1)->SetFooter(arg2);
83002     } catch (std::out_of_range& e) {
83003       {
83004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83005       };
83006     } catch (std::exception& e) {
83007       {
83008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83009       };
83010     } catch (Dali::DaliException e) {
83011       {
83012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83013       };
83014     } catch (...) {
83015       {
83016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83017       };
83018     }
83019   }
83020
83021 }
83022
83023
83024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83025   void * jresult ;
83026   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83027   Dali::Actor result;
83028
83029   arg1 = (Dali::Toolkit::Popup *)jarg1;
83030   {
83031     try {
83032       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83033     } catch (std::out_of_range& e) {
83034       {
83035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83036       };
83037     } catch (std::exception& e) {
83038       {
83039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83040       };
83041     } catch (Dali::DaliException e) {
83042       {
83043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83044       };
83045     } catch (...) {
83046       {
83047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83048       };
83049     }
83050   }
83051
83052   jresult = new Dali::Actor((const Dali::Actor &)result);
83053   return jresult;
83054 }
83055
83056
83057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83058   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83059   Dali::Toolkit::Popup::DisplayState arg2 ;
83060
83061   arg1 = (Dali::Toolkit::Popup *)jarg1;
83062   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83063   {
83064     try {
83065       (arg1)->SetDisplayState(arg2);
83066     } catch (std::out_of_range& e) {
83067       {
83068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83069       };
83070     } catch (std::exception& e) {
83071       {
83072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83073       };
83074     } catch (Dali::DaliException e) {
83075       {
83076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83077       };
83078     } catch (...) {
83079       {
83080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83081       };
83082     }
83083   }
83084
83085 }
83086
83087
83088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83089   int jresult ;
83090   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83091   Dali::Toolkit::Popup::DisplayState result;
83092
83093   arg1 = (Dali::Toolkit::Popup *)jarg1;
83094   {
83095     try {
83096       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83097     } catch (std::out_of_range& e) {
83098       {
83099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83100       };
83101     } catch (std::exception& e) {
83102       {
83103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83104       };
83105     } catch (Dali::DaliException e) {
83106       {
83107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83108       };
83109     } catch (...) {
83110       {
83111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83112       };
83113     }
83114   }
83115
83116   jresult = (int)result;
83117   return jresult;
83118 }
83119
83120
83121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83122   void * jresult ;
83123   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83124   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83125
83126   arg1 = (Dali::Toolkit::Popup *)jarg1;
83127   {
83128     try {
83129       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83130     } catch (std::out_of_range& e) {
83131       {
83132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83133       };
83134     } catch (std::exception& e) {
83135       {
83136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83137       };
83138     } catch (Dali::DaliException e) {
83139       {
83140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83141       };
83142     } catch (...) {
83143       {
83144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83145       };
83146     }
83147   }
83148
83149   jresult = (void *)result;
83150   return jresult;
83151 }
83152
83153
83154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83155   void * jresult ;
83156   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83157   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83158
83159   arg1 = (Dali::Toolkit::Popup *)jarg1;
83160   {
83161     try {
83162       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83163     } catch (std::out_of_range& e) {
83164       {
83165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83166       };
83167     } catch (std::exception& e) {
83168       {
83169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83170       };
83171     } catch (Dali::DaliException e) {
83172       {
83173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83174       };
83175     } catch (...) {
83176       {
83177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83178       };
83179     }
83180   }
83181
83182   jresult = (void *)result;
83183   return jresult;
83184 }
83185
83186
83187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83188   void * jresult ;
83189   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83190   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83191
83192   arg1 = (Dali::Toolkit::Popup *)jarg1;
83193   {
83194     try {
83195       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83196     } catch (std::out_of_range& e) {
83197       {
83198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83199       };
83200     } catch (std::exception& e) {
83201       {
83202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83203       };
83204     } catch (Dali::DaliException e) {
83205       {
83206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83207       };
83208     } catch (...) {
83209       {
83210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83211       };
83212     }
83213   }
83214
83215   jresult = (void *)result;
83216   return jresult;
83217 }
83218
83219
83220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83221   void * jresult ;
83222   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83223   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83224
83225   arg1 = (Dali::Toolkit::Popup *)jarg1;
83226   {
83227     try {
83228       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83229     } catch (std::out_of_range& e) {
83230       {
83231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83232       };
83233     } catch (std::exception& e) {
83234       {
83235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83236       };
83237     } catch (Dali::DaliException e) {
83238       {
83239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83240       };
83241     } catch (...) {
83242       {
83243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83244       };
83245     }
83246   }
83247
83248   jresult = (void *)result;
83249   return jresult;
83250 }
83251
83252
83253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83254   void * jresult ;
83255   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83256   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83257
83258   arg1 = (Dali::Toolkit::Popup *)jarg1;
83259   {
83260     try {
83261       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83262     } catch (std::out_of_range& e) {
83263       {
83264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83265       };
83266     } catch (std::exception& e) {
83267       {
83268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83269       };
83270     } catch (Dali::DaliException e) {
83271       {
83272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83273       };
83274     } catch (...) {
83275       {
83276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83277       };
83278     }
83279   }
83280
83281   jresult = (void *)result;
83282   return jresult;
83283 }
83284
83285
83286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83287   int jresult ;
83288   int result;
83289
83290   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83291   jresult = (int)result;
83292   return jresult;
83293 }
83294
83295
83296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83297   int jresult ;
83298   int result;
83299
83300   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83301   jresult = (int)result;
83302   return jresult;
83303 }
83304
83305
83306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83307   int jresult ;
83308   int result;
83309
83310   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83311   jresult = (int)result;
83312   return jresult;
83313 }
83314
83315
83316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83317   int jresult ;
83318   int result;
83319
83320   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83321   jresult = (int)result;
83322   return jresult;
83323 }
83324
83325
83326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83327   int jresult ;
83328   int result;
83329
83330   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83331   jresult = (int)result;
83332   return jresult;
83333 }
83334
83335
83336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83337   int jresult ;
83338   int result;
83339
83340   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83341   jresult = (int)result;
83342   return jresult;
83343 }
83344
83345
83346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83347   int jresult ;
83348   int result;
83349
83350   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83351   jresult = (int)result;
83352   return jresult;
83353 }
83354
83355
83356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83357   int jresult ;
83358   int result;
83359
83360   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83361   jresult = (int)result;
83362   return jresult;
83363 }
83364
83365
83366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83367   int jresult ;
83368   int result;
83369
83370   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83371   jresult = (int)result;
83372   return jresult;
83373 }
83374
83375
83376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83377   void * jresult ;
83378   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83379
83380   {
83381     try {
83382       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83383     } catch (std::out_of_range& e) {
83384       {
83385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83386       };
83387     } catch (std::exception& e) {
83388       {
83389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83390       };
83391     } catch (Dali::DaliException e) {
83392       {
83393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83394       };
83395     } catch (...) {
83396       {
83397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83398       };
83399     }
83400   }
83401
83402   jresult = (void *)result;
83403   return jresult;
83404 }
83405
83406
83407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83408   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83409
83410   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83411   {
83412     try {
83413       delete arg1;
83414     } catch (std::out_of_range& e) {
83415       {
83416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83417       };
83418     } catch (std::exception& e) {
83419       {
83420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83421       };
83422     } catch (Dali::DaliException e) {
83423       {
83424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83425       };
83426     } catch (...) {
83427       {
83428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83429       };
83430     }
83431   }
83432
83433 }
83434
83435
83436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83437   void * jresult ;
83438   Dali::Toolkit::ProgressBar result;
83439
83440   {
83441     try {
83442       result = Dali::Toolkit::ProgressBar::New();
83443     } catch (std::out_of_range& e) {
83444       {
83445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83446       };
83447     } catch (std::exception& e) {
83448       {
83449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83450       };
83451     } catch (Dali::DaliException e) {
83452       {
83453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83454       };
83455     } catch (...) {
83456       {
83457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83458       };
83459     }
83460   }
83461
83462   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83463   return jresult;
83464 }
83465
83466
83467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83468   void * jresult ;
83469   Dali::Toolkit::ProgressBar *result = 0 ;
83470
83471   {
83472     try {
83473       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83474     } catch (std::out_of_range& e) {
83475       {
83476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83477       };
83478     } catch (std::exception& e) {
83479       {
83480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83481       };
83482     } catch (Dali::DaliException e) {
83483       {
83484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83485       };
83486     } catch (...) {
83487       {
83488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83489       };
83490     }
83491   }
83492
83493   jresult = (void *)result;
83494   return jresult;
83495 }
83496
83497
83498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83499   void * jresult ;
83500   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83501   Dali::Toolkit::ProgressBar *result = 0 ;
83502
83503   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83504   if (!arg1) {
83505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83506     return 0;
83507   }
83508   {
83509     try {
83510       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83511     } catch (std::out_of_range& e) {
83512       {
83513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83514       };
83515     } catch (std::exception& e) {
83516       {
83517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83518       };
83519     } catch (Dali::DaliException e) {
83520       {
83521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83522       };
83523     } catch (...) {
83524       {
83525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83526       };
83527     }
83528   }
83529
83530   jresult = (void *)result;
83531   return jresult;
83532 }
83533
83534
83535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83536   void * jresult ;
83537   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83538   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83539   Dali::Toolkit::ProgressBar *result = 0 ;
83540
83541   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83542   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83543   if (!arg2) {
83544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83545     return 0;
83546   }
83547   {
83548     try {
83549       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83550     } catch (std::out_of_range& e) {
83551       {
83552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83553       };
83554     } catch (std::exception& e) {
83555       {
83556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83557       };
83558     } catch (Dali::DaliException e) {
83559       {
83560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83561       };
83562     } catch (...) {
83563       {
83564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83565       };
83566     }
83567   }
83568
83569   jresult = (void *)result;
83570   return jresult;
83571 }
83572
83573
83574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83575   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83576
83577   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83578   {
83579     try {
83580       delete arg1;
83581     } catch (std::out_of_range& e) {
83582       {
83583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83584       };
83585     } catch (std::exception& e) {
83586       {
83587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83588       };
83589     } catch (Dali::DaliException e) {
83590       {
83591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83592       };
83593     } catch (...) {
83594       {
83595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83596       };
83597     }
83598   }
83599
83600 }
83601
83602
83603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83604   void * jresult ;
83605   Dali::BaseHandle arg1 ;
83606   Dali::BaseHandle *argp1 ;
83607   Dali::Toolkit::ProgressBar result;
83608
83609   argp1 = (Dali::BaseHandle *)jarg1;
83610   if (!argp1) {
83611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83612     return 0;
83613   }
83614   arg1 = *argp1;
83615   {
83616     try {
83617       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83618     } catch (std::out_of_range& e) {
83619       {
83620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83621       };
83622     } catch (std::exception& e) {
83623       {
83624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83625       };
83626     } catch (Dali::DaliException e) {
83627       {
83628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83629       };
83630     } catch (...) {
83631       {
83632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83633       };
83634     }
83635   }
83636
83637   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83638   return jresult;
83639 }
83640
83641
83642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83643   void * jresult ;
83644   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83645   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83646
83647   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83648   {
83649     try {
83650       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83651     } catch (std::out_of_range& e) {
83652       {
83653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83654       };
83655     } catch (std::exception& e) {
83656       {
83657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83658       };
83659     } catch (Dali::DaliException e) {
83660       {
83661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83662       };
83663     } catch (...) {
83664       {
83665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83666       };
83667     }
83668   }
83669
83670   jresult = (void *)result;
83671   return jresult;
83672 }
83673
83674
83675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83676   void * jresult ;
83677   Dali::Toolkit::GaussianBlurView *result = 0 ;
83678
83679   {
83680     try {
83681       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83682     } catch (std::out_of_range& e) {
83683       {
83684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83685       };
83686     } catch (std::exception& e) {
83687       {
83688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83689       };
83690     } catch (Dali::DaliException e) {
83691       {
83692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83693       };
83694     } catch (...) {
83695       {
83696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83697       };
83698     }
83699   }
83700
83701   jresult = (void *)result;
83702   return jresult;
83703 }
83704
83705
83706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83707   void * jresult ;
83708   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83709   Dali::Toolkit::GaussianBlurView *result = 0 ;
83710
83711   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83712   if (!arg1) {
83713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83714     return 0;
83715   }
83716   {
83717     try {
83718       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83719     } catch (std::out_of_range& e) {
83720       {
83721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83722       };
83723     } catch (std::exception& e) {
83724       {
83725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83726       };
83727     } catch (Dali::DaliException e) {
83728       {
83729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83730       };
83731     } catch (...) {
83732       {
83733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83734       };
83735     }
83736   }
83737
83738   jresult = (void *)result;
83739   return jresult;
83740 }
83741
83742
83743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83744   void * jresult ;
83745   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83746   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83747   Dali::Toolkit::GaussianBlurView *result = 0 ;
83748
83749   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83750   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83751   if (!arg2) {
83752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83753     return 0;
83754   }
83755   {
83756     try {
83757       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83758     } catch (std::out_of_range& e) {
83759       {
83760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83761       };
83762     } catch (std::exception& e) {
83763       {
83764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83765       };
83766     } catch (Dali::DaliException e) {
83767       {
83768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83769       };
83770     } catch (...) {
83771       {
83772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83773       };
83774     }
83775   }
83776
83777   jresult = (void *)result;
83778   return jresult;
83779 }
83780
83781
83782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83783   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83784
83785   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83786   {
83787     try {
83788       delete arg1;
83789     } catch (std::out_of_range& e) {
83790       {
83791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83792       };
83793     } catch (std::exception& e) {
83794       {
83795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83796       };
83797     } catch (Dali::DaliException e) {
83798       {
83799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83800       };
83801     } catch (...) {
83802       {
83803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83804       };
83805     }
83806   }
83807
83808 }
83809
83810
83811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83812   void * jresult ;
83813   Dali::BaseHandle arg1 ;
83814   Dali::BaseHandle *argp1 ;
83815   Dali::Toolkit::GaussianBlurView result;
83816
83817   argp1 = (Dali::BaseHandle *)jarg1;
83818   if (!argp1) {
83819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83820     return 0;
83821   }
83822   arg1 = *argp1;
83823   {
83824     try {
83825       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83826     } catch (std::out_of_range& e) {
83827       {
83828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83829       };
83830     } catch (std::exception& e) {
83831       {
83832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83833       };
83834     } catch (Dali::DaliException e) {
83835       {
83836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83837       };
83838     } catch (...) {
83839       {
83840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83841       };
83842     }
83843   }
83844
83845   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83846   return jresult;
83847 }
83848
83849
83850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83851   void * jresult ;
83852   Dali::Toolkit::GaussianBlurView result;
83853
83854   {
83855     try {
83856       result = Dali::Toolkit::GaussianBlurView::New();
83857     } catch (std::out_of_range& e) {
83858       {
83859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83860       };
83861     } catch (std::exception& e) {
83862       {
83863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83864       };
83865     } catch (Dali::DaliException e) {
83866       {
83867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83868       };
83869     } catch (...) {
83870       {
83871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83872       };
83873     }
83874   }
83875
83876   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83877   return jresult;
83878 }
83879
83880
83881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83882   void * jresult ;
83883   unsigned int arg1 ;
83884   float arg2 ;
83885   Dali::Pixel::Format arg3 ;
83886   float arg4 ;
83887   float arg5 ;
83888   bool arg6 ;
83889   Dali::Toolkit::GaussianBlurView result;
83890
83891   arg1 = (unsigned int)jarg1;
83892   arg2 = (float)jarg2;
83893   arg3 = (Dali::Pixel::Format)jarg3;
83894   arg4 = (float)jarg4;
83895   arg5 = (float)jarg5;
83896   arg6 = jarg6 ? true : false;
83897   {
83898     try {
83899       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83900     } catch (std::out_of_range& e) {
83901       {
83902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83903       };
83904     } catch (std::exception& e) {
83905       {
83906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83907       };
83908     } catch (Dali::DaliException e) {
83909       {
83910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83911       };
83912     } catch (...) {
83913       {
83914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83915       };
83916     }
83917   }
83918
83919   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83920   return jresult;
83921 }
83922
83923
83924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83925   void * jresult ;
83926   unsigned int arg1 ;
83927   float arg2 ;
83928   Dali::Pixel::Format arg3 ;
83929   float arg4 ;
83930   float arg5 ;
83931   Dali::Toolkit::GaussianBlurView result;
83932
83933   arg1 = (unsigned int)jarg1;
83934   arg2 = (float)jarg2;
83935   arg3 = (Dali::Pixel::Format)jarg3;
83936   arg4 = (float)jarg4;
83937   arg5 = (float)jarg5;
83938   {
83939     try {
83940       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83941     } catch (std::out_of_range& e) {
83942       {
83943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83944       };
83945     } catch (std::exception& e) {
83946       {
83947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83948       };
83949     } catch (Dali::DaliException e) {
83950       {
83951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83952       };
83953     } catch (...) {
83954       {
83955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83956       };
83957     }
83958   }
83959
83960   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83961   return jresult;
83962 }
83963
83964
83965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83966   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83967   Dali::Actor arg2 ;
83968   Dali::Actor *argp2 ;
83969
83970   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83971   argp2 = (Dali::Actor *)jarg2;
83972   if (!argp2) {
83973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83974     return ;
83975   }
83976   arg2 = *argp2;
83977   {
83978     try {
83979       (arg1)->Add(arg2);
83980     } catch (std::out_of_range& e) {
83981       {
83982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83983       };
83984     } catch (std::exception& e) {
83985       {
83986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83987       };
83988     } catch (Dali::DaliException e) {
83989       {
83990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83991       };
83992     } catch (...) {
83993       {
83994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83995       };
83996     }
83997   }
83998
83999 }
84000
84001
84002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84003   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84004   Dali::Actor arg2 ;
84005   Dali::Actor *argp2 ;
84006
84007   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84008   argp2 = (Dali::Actor *)jarg2;
84009   if (!argp2) {
84010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84011     return ;
84012   }
84013   arg2 = *argp2;
84014   {
84015     try {
84016       (arg1)->Remove(arg2);
84017     } catch (std::out_of_range& e) {
84018       {
84019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84020       };
84021     } catch (std::exception& e) {
84022       {
84023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84024       };
84025     } catch (Dali::DaliException e) {
84026       {
84027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84028       };
84029     } catch (...) {
84030       {
84031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84032       };
84033     }
84034   }
84035
84036 }
84037
84038
84039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84040   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84041
84042   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84043   {
84044     try {
84045       (arg1)->Activate();
84046     } catch (std::out_of_range& e) {
84047       {
84048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84049       };
84050     } catch (std::exception& e) {
84051       {
84052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84053       };
84054     } catch (Dali::DaliException e) {
84055       {
84056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84057       };
84058     } catch (...) {
84059       {
84060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84061       };
84062     }
84063   }
84064
84065 }
84066
84067
84068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84069   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84070
84071   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84072   {
84073     try {
84074       (arg1)->ActivateOnce();
84075     } catch (std::out_of_range& e) {
84076       {
84077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84078       };
84079     } catch (std::exception& e) {
84080       {
84081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84082       };
84083     } catch (Dali::DaliException e) {
84084       {
84085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84086       };
84087     } catch (...) {
84088       {
84089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84090       };
84091     }
84092   }
84093
84094 }
84095
84096
84097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84098   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84099
84100   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84101   {
84102     try {
84103       (arg1)->Deactivate();
84104     } catch (std::out_of_range& e) {
84105       {
84106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84107       };
84108     } catch (std::exception& e) {
84109       {
84110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84111       };
84112     } catch (Dali::DaliException e) {
84113       {
84114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84115       };
84116     } catch (...) {
84117       {
84118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84119       };
84120     }
84121   }
84122
84123 }
84124
84125
84126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84127   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84128   Dali::Texture arg2 ;
84129   Dali::FrameBuffer arg3 ;
84130   Dali::Texture *argp2 ;
84131   Dali::FrameBuffer *argp3 ;
84132
84133   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84134   argp2 = (Dali::Texture *)jarg2;
84135   if (!argp2) {
84136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
84137     return ;
84138   }
84139   arg2 = *argp2;
84140   argp3 = (Dali::FrameBuffer *)jarg3;
84141   if (!argp3) {
84142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
84143     return ;
84144   }
84145   arg3 = *argp3;
84146   {
84147     try {
84148       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84149     } catch (std::out_of_range& e) {
84150       {
84151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84152       };
84153     } catch (std::exception& e) {
84154       {
84155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84156       };
84157     } catch (Dali::DaliException e) {
84158       {
84159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84160       };
84161     } catch (...) {
84162       {
84163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84164       };
84165     }
84166   }
84167
84168 }
84169
84170
84171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84172   int jresult ;
84173   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84174   Dali::Property::Index result;
84175
84176   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84177   {
84178     try {
84179       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84180     } catch (std::out_of_range& e) {
84181       {
84182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84183       };
84184     } catch (std::exception& e) {
84185       {
84186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84187       };
84188     } catch (Dali::DaliException e) {
84189       {
84190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84191       };
84192     } catch (...) {
84193       {
84194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84195       };
84196     }
84197   }
84198
84199   jresult = result;
84200   return jresult;
84201 }
84202
84203
84204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84205   void * jresult ;
84206   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84207   Dali::FrameBuffer result;
84208
84209   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84210   {
84211     try {
84212       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84213     } catch (std::out_of_range& e) {
84214       {
84215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84216       };
84217     } catch (std::exception& e) {
84218       {
84219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84220       };
84221     } catch (Dali::DaliException e) {
84222       {
84223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84224       };
84225     } catch (...) {
84226       {
84227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84228       };
84229     }
84230   }
84231
84232   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84233   return jresult;
84234 }
84235
84236
84237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84238   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84239   Dali::Vector4 *arg2 = 0 ;
84240
84241   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84242   arg2 = (Dali::Vector4 *)jarg2;
84243   if (!arg2) {
84244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84245     return ;
84246   }
84247   {
84248     try {
84249       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84250     } catch (std::out_of_range& e) {
84251       {
84252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84253       };
84254     } catch (std::exception& e) {
84255       {
84256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84257       };
84258     } catch (Dali::DaliException e) {
84259       {
84260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84261       };
84262     } catch (...) {
84263       {
84264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84265       };
84266     }
84267   }
84268
84269 }
84270
84271
84272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84273   void * jresult ;
84274   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84275   Dali::Vector4 result;
84276
84277   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84278   {
84279     try {
84280       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84281     } catch (std::out_of_range& e) {
84282       {
84283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84284       };
84285     } catch (std::exception& e) {
84286       {
84287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84288       };
84289     } catch (Dali::DaliException e) {
84290       {
84291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84292       };
84293     } catch (...) {
84294       {
84295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84296       };
84297     }
84298   }
84299
84300   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84301   return jresult;
84302 }
84303
84304
84305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84306   void * jresult ;
84307   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84308   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84309
84310   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84311   {
84312     try {
84313       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84314     } catch (std::out_of_range& e) {
84315       {
84316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84317       };
84318     } catch (std::exception& e) {
84319       {
84320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84321       };
84322     } catch (Dali::DaliException e) {
84323       {
84324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84325       };
84326     } catch (...) {
84327       {
84328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84329       };
84330     }
84331   }
84332
84333   jresult = (void *)result;
84334   return jresult;
84335 }
84336
84337
84338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84339   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84340
84341   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84342   {
84343     try {
84344       delete arg1;
84345     } catch (std::out_of_range& e) {
84346       {
84347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84348       };
84349     } catch (std::exception& e) {
84350       {
84351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84352       };
84353     } catch (Dali::DaliException e) {
84354       {
84355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84356       };
84357     } catch (...) {
84358       {
84359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84360       };
84361     }
84362   }
84363
84364 }
84365
84366
84367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84368   unsigned int jresult ;
84369   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84370   unsigned int result;
84371
84372   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84373   {
84374     try {
84375       result = (unsigned int)(arg1)->GetNumberOfPages();
84376     } catch (std::out_of_range& e) {
84377       {
84378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84379       };
84380     } catch (std::exception& e) {
84381       {
84382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84383       };
84384     } catch (Dali::DaliException e) {
84385       {
84386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84387       };
84388     } catch (...) {
84389       {
84390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84391       };
84392     }
84393   }
84394
84395   jresult = result;
84396   return jresult;
84397 }
84398
84399
84400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84401   void * jresult ;
84402   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84403   unsigned int arg2 ;
84404   Dali::Texture result;
84405
84406   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84407   arg2 = (unsigned int)jarg2;
84408   {
84409     try {
84410       result = (arg1)->NewPage(arg2);
84411     } catch (std::out_of_range& e) {
84412       {
84413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84414       };
84415     } catch (std::exception& e) {
84416       {
84417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84418       };
84419     } catch (Dali::DaliException e) {
84420       {
84421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84422       };
84423     } catch (...) {
84424       {
84425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84426       };
84427     }
84428   }
84429
84430   jresult = new Dali::Texture((const Dali::Texture &)result);
84431   return jresult;
84432 }
84433
84434
84435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84436   int jresult ;
84437   int result;
84438
84439   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84440   jresult = (int)result;
84441   return jresult;
84442 }
84443
84444
84445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84446   int jresult ;
84447   int result;
84448
84449   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84450   jresult = (int)result;
84451   return jresult;
84452 }
84453
84454
84455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84456   int jresult ;
84457   int result;
84458
84459   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84460   jresult = (int)result;
84461   return jresult;
84462 }
84463
84464
84465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84466   void * jresult ;
84467   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84468
84469   {
84470     try {
84471       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84472     } catch (std::out_of_range& e) {
84473       {
84474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84475       };
84476     } catch (std::exception& e) {
84477       {
84478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84479       };
84480     } catch (Dali::DaliException e) {
84481       {
84482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84483       };
84484     } catch (...) {
84485       {
84486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84487       };
84488     }
84489   }
84490
84491   jresult = (void *)result;
84492   return jresult;
84493 }
84494
84495
84496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84497   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84498
84499   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84500   {
84501     try {
84502       delete arg1;
84503     } catch (std::out_of_range& e) {
84504       {
84505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84506       };
84507     } catch (std::exception& e) {
84508       {
84509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84510       };
84511     } catch (Dali::DaliException e) {
84512       {
84513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84514       };
84515     } catch (...) {
84516       {
84517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84518       };
84519     }
84520   }
84521
84522 }
84523
84524
84525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84526   void * jresult ;
84527   Dali::Toolkit::PageTurnView *result = 0 ;
84528
84529   {
84530     try {
84531       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84532     } catch (std::out_of_range& e) {
84533       {
84534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84535       };
84536     } catch (std::exception& e) {
84537       {
84538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84539       };
84540     } catch (Dali::DaliException e) {
84541       {
84542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84543       };
84544     } catch (...) {
84545       {
84546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84547       };
84548     }
84549   }
84550
84551   jresult = (void *)result;
84552   return jresult;
84553 }
84554
84555
84556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84557   void * jresult ;
84558   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84559   Dali::Toolkit::PageTurnView *result = 0 ;
84560
84561   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84562   if (!arg1) {
84563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84564     return 0;
84565   }
84566   {
84567     try {
84568       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84569     } catch (std::out_of_range& e) {
84570       {
84571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84572       };
84573     } catch (std::exception& e) {
84574       {
84575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84576       };
84577     } catch (Dali::DaliException e) {
84578       {
84579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84580       };
84581     } catch (...) {
84582       {
84583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84584       };
84585     }
84586   }
84587
84588   jresult = (void *)result;
84589   return jresult;
84590 }
84591
84592
84593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84594   void * jresult ;
84595   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84596   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84597   Dali::Toolkit::PageTurnView *result = 0 ;
84598
84599   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84600   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84601   if (!arg2) {
84602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84603     return 0;
84604   }
84605   {
84606     try {
84607       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84608     } catch (std::out_of_range& e) {
84609       {
84610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84611       };
84612     } catch (std::exception& e) {
84613       {
84614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84615       };
84616     } catch (Dali::DaliException e) {
84617       {
84618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84619       };
84620     } catch (...) {
84621       {
84622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84623       };
84624     }
84625   }
84626
84627   jresult = (void *)result;
84628   return jresult;
84629 }
84630
84631
84632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84633   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84634
84635   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84636   {
84637     try {
84638       delete arg1;
84639     } catch (std::out_of_range& e) {
84640       {
84641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84642       };
84643     } catch (std::exception& e) {
84644       {
84645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84646       };
84647     } catch (Dali::DaliException e) {
84648       {
84649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84650       };
84651     } catch (...) {
84652       {
84653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84654       };
84655     }
84656   }
84657
84658 }
84659
84660
84661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84662   void * jresult ;
84663   Dali::BaseHandle arg1 ;
84664   Dali::BaseHandle *argp1 ;
84665   Dali::Toolkit::PageTurnView result;
84666
84667   argp1 = (Dali::BaseHandle *)jarg1;
84668   if (!argp1) {
84669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84670     return 0;
84671   }
84672   arg1 = *argp1;
84673   {
84674     try {
84675       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84676     } catch (std::out_of_range& e) {
84677       {
84678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84679       };
84680     } catch (std::exception& e) {
84681       {
84682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84683       };
84684     } catch (Dali::DaliException e) {
84685       {
84686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84687       };
84688     } catch (...) {
84689       {
84690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84691       };
84692     }
84693   }
84694
84695   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84696   return jresult;
84697 }
84698
84699
84700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84701   void * jresult ;
84702   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84703   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84704
84705   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84706   {
84707     try {
84708       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84709     } catch (std::out_of_range& e) {
84710       {
84711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84712       };
84713     } catch (std::exception& e) {
84714       {
84715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84716       };
84717     } catch (Dali::DaliException e) {
84718       {
84719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84720       };
84721     } catch (...) {
84722       {
84723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84724       };
84725     }
84726   }
84727
84728   jresult = (void *)result;
84729   return jresult;
84730 }
84731
84732
84733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84734   void * jresult ;
84735   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84736   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84737
84738   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84739   {
84740     try {
84741       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84742     } catch (std::out_of_range& e) {
84743       {
84744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84745       };
84746     } catch (std::exception& e) {
84747       {
84748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84749       };
84750     } catch (Dali::DaliException e) {
84751       {
84752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84753       };
84754     } catch (...) {
84755       {
84756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84757       };
84758     }
84759   }
84760
84761   jresult = (void *)result;
84762   return jresult;
84763 }
84764
84765
84766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84767   void * jresult ;
84768   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84769   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84770
84771   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84772   {
84773     try {
84774       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84775     } catch (std::out_of_range& e) {
84776       {
84777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84778       };
84779     } catch (std::exception& e) {
84780       {
84781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84782       };
84783     } catch (Dali::DaliException e) {
84784       {
84785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84786       };
84787     } catch (...) {
84788       {
84789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84790       };
84791     }
84792   }
84793
84794   jresult = (void *)result;
84795   return jresult;
84796 }
84797
84798
84799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84800   void * jresult ;
84801   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84802   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84803
84804   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84805   {
84806     try {
84807       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84808     } catch (std::out_of_range& e) {
84809       {
84810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84811       };
84812     } catch (std::exception& e) {
84813       {
84814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84815       };
84816     } catch (Dali::DaliException e) {
84817       {
84818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84819       };
84820     } catch (...) {
84821       {
84822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84823       };
84824     }
84825   }
84826
84827   jresult = (void *)result;
84828   return jresult;
84829 }
84830
84831
84832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84833   void * jresult ;
84834   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84835
84836   {
84837     try {
84838       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84839     } catch (std::out_of_range& e) {
84840       {
84841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84842       };
84843     } catch (std::exception& e) {
84844       {
84845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84846       };
84847     } catch (Dali::DaliException e) {
84848       {
84849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84850       };
84851     } catch (...) {
84852       {
84853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84854       };
84855     }
84856   }
84857
84858   jresult = (void *)result;
84859   return jresult;
84860 }
84861
84862
84863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84864   void * jresult ;
84865   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84866   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84867
84868   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84869   if (!arg1) {
84870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84871     return 0;
84872   }
84873   {
84874     try {
84875       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*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 = (void *)result;
84896   return jresult;
84897 }
84898
84899
84900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84901   void * jresult ;
84902   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84903   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84904   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84905
84906   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84907   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84908   if (!arg2) {
84909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84910     return 0;
84911   }
84912   {
84913     try {
84914       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84915     } catch (std::out_of_range& e) {
84916       {
84917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84918       };
84919     } catch (std::exception& e) {
84920       {
84921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84922       };
84923     } catch (Dali::DaliException e) {
84924       {
84925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84926       };
84927     } catch (...) {
84928       {
84929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84930       };
84931     }
84932   }
84933
84934   jresult = (void *)result;
84935   return jresult;
84936 }
84937
84938
84939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84940   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84941
84942   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84943   {
84944     try {
84945       delete arg1;
84946     } catch (std::out_of_range& e) {
84947       {
84948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84949       };
84950     } catch (std::exception& e) {
84951       {
84952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84953       };
84954     } catch (Dali::DaliException e) {
84955       {
84956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84957       };
84958     } catch (...) {
84959       {
84960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84961       };
84962     }
84963   }
84964
84965 }
84966
84967
84968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84969   void * jresult ;
84970   Dali::Toolkit::PageFactory *arg1 = 0 ;
84971   Dali::Vector2 *arg2 = 0 ;
84972   Dali::Toolkit::PageTurnLandscapeView result;
84973
84974   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84975   if (!arg1) {
84976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84977     return 0;
84978   }
84979   arg2 = (Dali::Vector2 *)jarg2;
84980   if (!arg2) {
84981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84982     return 0;
84983   }
84984   {
84985     try {
84986       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84987     } catch (std::out_of_range& e) {
84988       {
84989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84990       };
84991     } catch (std::exception& e) {
84992       {
84993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84994       };
84995     } catch (Dali::DaliException e) {
84996       {
84997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84998       };
84999     } catch (...) {
85000       {
85001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85002       };
85003     }
85004   }
85005
85006   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85007   return jresult;
85008 }
85009
85010
85011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
85012   void * jresult ;
85013   Dali::BaseHandle arg1 ;
85014   Dali::BaseHandle *argp1 ;
85015   Dali::Toolkit::PageTurnLandscapeView result;
85016
85017   argp1 = (Dali::BaseHandle *)jarg1;
85018   if (!argp1) {
85019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85020     return 0;
85021   }
85022   arg1 = *argp1;
85023   {
85024     try {
85025       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
85026     } catch (std::out_of_range& e) {
85027       {
85028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85029       };
85030     } catch (std::exception& e) {
85031       {
85032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85033       };
85034     } catch (Dali::DaliException e) {
85035       {
85036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85037       };
85038     } catch (...) {
85039       {
85040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85041       };
85042     }
85043   }
85044
85045   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85046   return jresult;
85047 }
85048
85049
85050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85051   void * jresult ;
85052   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85053
85054   {
85055     try {
85056       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85057     } catch (std::out_of_range& e) {
85058       {
85059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85060       };
85061     } catch (std::exception& e) {
85062       {
85063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85064       };
85065     } catch (Dali::DaliException e) {
85066       {
85067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85068       };
85069     } catch (...) {
85070       {
85071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85072       };
85073     }
85074   }
85075
85076   jresult = (void *)result;
85077   return jresult;
85078 }
85079
85080
85081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85082   void * jresult ;
85083   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85084   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85085
85086   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85087   if (!arg1) {
85088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85089     return 0;
85090   }
85091   {
85092     try {
85093       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*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 = (void *)result;
85114   return jresult;
85115 }
85116
85117
85118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85119   void * jresult ;
85120   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85121   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85122   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85123
85124   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85125   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85126   if (!arg2) {
85127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85128     return 0;
85129   }
85130   {
85131     try {
85132       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85133     } catch (std::out_of_range& e) {
85134       {
85135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85136       };
85137     } catch (std::exception& e) {
85138       {
85139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85140       };
85141     } catch (Dali::DaliException e) {
85142       {
85143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85144       };
85145     } catch (...) {
85146       {
85147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85148       };
85149     }
85150   }
85151
85152   jresult = (void *)result;
85153   return jresult;
85154 }
85155
85156
85157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85158   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85159
85160   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85161   {
85162     try {
85163       delete arg1;
85164     } catch (std::out_of_range& e) {
85165       {
85166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85167       };
85168     } catch (std::exception& e) {
85169       {
85170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85171       };
85172     } catch (Dali::DaliException e) {
85173       {
85174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85175       };
85176     } catch (...) {
85177       {
85178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85179       };
85180     }
85181   }
85182
85183 }
85184
85185
85186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85187   void * jresult ;
85188   Dali::Toolkit::PageFactory *arg1 = 0 ;
85189   Dali::Vector2 *arg2 = 0 ;
85190   Dali::Toolkit::PageTurnPortraitView result;
85191
85192   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85193   if (!arg1) {
85194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85195     return 0;
85196   }
85197   arg2 = (Dali::Vector2 *)jarg2;
85198   if (!arg2) {
85199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85200     return 0;
85201   }
85202   {
85203     try {
85204       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85205     } catch (std::out_of_range& e) {
85206       {
85207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85208       };
85209     } catch (std::exception& e) {
85210       {
85211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85212       };
85213     } catch (Dali::DaliException e) {
85214       {
85215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85216       };
85217     } catch (...) {
85218       {
85219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85220       };
85221     }
85222   }
85223
85224   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85225   return jresult;
85226 }
85227
85228
85229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85230   void * jresult ;
85231   Dali::BaseHandle arg1 ;
85232   Dali::BaseHandle *argp1 ;
85233   Dali::Toolkit::PageTurnPortraitView result;
85234
85235   argp1 = (Dali::BaseHandle *)jarg1;
85236   if (!argp1) {
85237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85238     return 0;
85239   }
85240   arg1 = *argp1;
85241   {
85242     try {
85243       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85244     } catch (std::out_of_range& e) {
85245       {
85246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85247       };
85248     } catch (std::exception& e) {
85249       {
85250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85251       };
85252     } catch (Dali::DaliException e) {
85253       {
85254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85255       };
85256     } catch (...) {
85257       {
85258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85259       };
85260     }
85261   }
85262
85263   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85264   return jresult;
85265 }
85266
85267
85268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85269   int jresult ;
85270   int result;
85271
85272   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85273   jresult = (int)result;
85274   return jresult;
85275 }
85276
85277
85278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85279   int jresult ;
85280   int result;
85281
85282   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85283   jresult = (int)result;
85284   return jresult;
85285 }
85286
85287
85288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85289   int jresult ;
85290   int result;
85291
85292   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85293   jresult = (int)result;
85294   return jresult;
85295 }
85296
85297
85298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85299   void * jresult ;
85300   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85301
85302   {
85303     try {
85304       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85305     } catch (std::out_of_range& e) {
85306       {
85307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85308       };
85309     } catch (std::exception& e) {
85310       {
85311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85312       };
85313     } catch (Dali::DaliException e) {
85314       {
85315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85316       };
85317     } catch (...) {
85318       {
85319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85320       };
85321     }
85322   }
85323
85324   jresult = (void *)result;
85325   return jresult;
85326 }
85327
85328
85329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85330   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85331
85332   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85333   {
85334     try {
85335       delete arg1;
85336     } catch (std::out_of_range& e) {
85337       {
85338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85339       };
85340     } catch (std::exception& e) {
85341       {
85342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85343       };
85344     } catch (Dali::DaliException e) {
85345       {
85346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85347       };
85348     } catch (...) {
85349       {
85350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85351       };
85352     }
85353   }
85354
85355 }
85356
85357
85358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85359   void * jresult ;
85360   Dali::Toolkit::ToggleButton *result = 0 ;
85361
85362   {
85363     try {
85364       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85365     } catch (std::out_of_range& e) {
85366       {
85367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85368       };
85369     } catch (std::exception& e) {
85370       {
85371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85372       };
85373     } catch (Dali::DaliException e) {
85374       {
85375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85376       };
85377     } catch (...) {
85378       {
85379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85380       };
85381     }
85382   }
85383
85384   jresult = (void *)result;
85385   return jresult;
85386 }
85387
85388
85389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85390   void * jresult ;
85391   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85392   Dali::Toolkit::ToggleButton *result = 0 ;
85393
85394   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85395   if (!arg1) {
85396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85397     return 0;
85398   }
85399   {
85400     try {
85401       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85402     } catch (std::out_of_range& e) {
85403       {
85404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85405       };
85406     } catch (std::exception& e) {
85407       {
85408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85409       };
85410     } catch (Dali::DaliException e) {
85411       {
85412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85413       };
85414     } catch (...) {
85415       {
85416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85417       };
85418     }
85419   }
85420
85421   jresult = (void *)result;
85422   return jresult;
85423 }
85424
85425
85426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85427   void * jresult ;
85428   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85429   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85430   Dali::Toolkit::ToggleButton *result = 0 ;
85431
85432   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85433   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85434   if (!arg2) {
85435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85436     return 0;
85437   }
85438   {
85439     try {
85440       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85441     } catch (std::out_of_range& e) {
85442       {
85443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85444       };
85445     } catch (std::exception& e) {
85446       {
85447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85448       };
85449     } catch (Dali::DaliException e) {
85450       {
85451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85452       };
85453     } catch (...) {
85454       {
85455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85456       };
85457     }
85458   }
85459
85460   jresult = (void *)result;
85461   return jresult;
85462 }
85463
85464
85465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85466   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85467
85468   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85469   {
85470     try {
85471       delete arg1;
85472     } catch (std::out_of_range& e) {
85473       {
85474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85475       };
85476     } catch (std::exception& e) {
85477       {
85478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85479       };
85480     } catch (Dali::DaliException e) {
85481       {
85482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85483       };
85484     } catch (...) {
85485       {
85486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85487       };
85488     }
85489   }
85490
85491 }
85492
85493
85494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85495   void * jresult ;
85496   Dali::Toolkit::ToggleButton result;
85497
85498   {
85499     try {
85500       result = Dali::Toolkit::ToggleButton::New();
85501     } catch (std::out_of_range& e) {
85502       {
85503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85504       };
85505     } catch (std::exception& e) {
85506       {
85507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85508       };
85509     } catch (Dali::DaliException e) {
85510       {
85511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85512       };
85513     } catch (...) {
85514       {
85515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85516       };
85517     }
85518   }
85519
85520   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85521   return jresult;
85522 }
85523
85524
85525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85526   void * jresult ;
85527   Dali::BaseHandle arg1 ;
85528   Dali::BaseHandle *argp1 ;
85529   Dali::Toolkit::ToggleButton result;
85530
85531   argp1 = (Dali::BaseHandle *)jarg1;
85532   if (!argp1) {
85533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85534     return 0;
85535   }
85536   arg1 = *argp1;
85537   {
85538     try {
85539       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85540     } catch (std::out_of_range& e) {
85541       {
85542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85543       };
85544     } catch (std::exception& e) {
85545       {
85546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85547       };
85548     } catch (Dali::DaliException e) {
85549       {
85550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85551       };
85552     } catch (...) {
85553       {
85554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85555       };
85556     }
85557   }
85558
85559   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85560   return jresult;
85561 }
85562
85563
85564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85565   void * jresult ;
85566   Dali::Toolkit::Visual::Base *result = 0 ;
85567
85568   {
85569     try {
85570       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85571     } catch (std::out_of_range& e) {
85572       {
85573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85574       };
85575     } catch (std::exception& e) {
85576       {
85577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85578       };
85579     } catch (Dali::DaliException e) {
85580       {
85581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85582       };
85583     } catch (...) {
85584       {
85585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85586       };
85587     }
85588   }
85589
85590   jresult = (void *)result;
85591   return jresult;
85592 }
85593
85594
85595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85596   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85597
85598   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85599   {
85600     try {
85601       delete arg1;
85602     } catch (std::out_of_range& e) {
85603       {
85604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85605       };
85606     } catch (std::exception& e) {
85607       {
85608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85609       };
85610     } catch (Dali::DaliException e) {
85611       {
85612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85613       };
85614     } catch (...) {
85615       {
85616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85617       };
85618     }
85619   }
85620
85621 }
85622
85623
85624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85625   void * jresult ;
85626   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85627   Dali::Toolkit::Visual::Base *result = 0 ;
85628
85629   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85630   if (!arg1) {
85631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85632     return 0;
85633   }
85634   {
85635     try {
85636       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85637     } catch (std::out_of_range& e) {
85638       {
85639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85640       };
85641     } catch (std::exception& e) {
85642       {
85643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85644       };
85645     } catch (Dali::DaliException e) {
85646       {
85647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85648       };
85649     } catch (...) {
85650       {
85651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85652       };
85653     }
85654   }
85655
85656   jresult = (void *)result;
85657   return jresult;
85658 }
85659
85660
85661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85662   void * jresult ;
85663   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85664   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85665   Dali::Toolkit::Visual::Base *result = 0 ;
85666
85667   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85668   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85669   if (!arg2) {
85670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85671     return 0;
85672   }
85673   {
85674     try {
85675       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*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 = (void *)result;
85696   return jresult;
85697 }
85698
85699
85700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85701   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85702   std::string *arg2 = 0 ;
85703
85704   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85705   if (!jarg2) {
85706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85707     return ;
85708   }
85709   std::string arg2_str(jarg2);
85710   arg2 = &arg2_str;
85711   {
85712     try {
85713       (arg1)->SetName((std::string const &)*arg2);
85714     } catch (std::out_of_range& e) {
85715       {
85716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85717       };
85718     } catch (std::exception& e) {
85719       {
85720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85721       };
85722     } catch (Dali::DaliException e) {
85723       {
85724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85725       };
85726     } catch (...) {
85727       {
85728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85729       };
85730     }
85731   }
85732
85733
85734   //argout typemap for const std::string&
85735
85736 }
85737
85738
85739 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85740   char * jresult ;
85741   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85742   std::string *result = 0 ;
85743
85744   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85745   {
85746     try {
85747       result = (std::string *) &(arg1)->GetName();
85748     } catch (std::out_of_range& e) {
85749       {
85750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85751       };
85752     } catch (std::exception& e) {
85753       {
85754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85755       };
85756     } catch (Dali::DaliException e) {
85757       {
85758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85759       };
85760     } catch (...) {
85761       {
85762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85763       };
85764     }
85765   }
85766
85767   jresult = SWIG_csharp_string_callback(result->c_str());
85768   return jresult;
85769 }
85770
85771
85772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85773   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85774   Dali::Property::Map *arg2 = 0 ;
85775   Dali::Size arg3 ;
85776   Dali::Size *argp3 ;
85777
85778   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85779   arg2 = (Dali::Property::Map *)jarg2;
85780   if (!arg2) {
85781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85782     return ;
85783   }
85784   argp3 = (Dali::Size *)jarg3;
85785   if (!argp3) {
85786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85787     return ;
85788   }
85789   arg3 = *argp3;
85790   {
85791     try {
85792       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85793     } catch (std::out_of_range& e) {
85794       {
85795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85796       };
85797     } catch (std::exception& e) {
85798       {
85799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85800       };
85801     } catch (Dali::DaliException e) {
85802       {
85803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85804       };
85805     } catch (...) {
85806       {
85807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85808       };
85809     }
85810   }
85811
85812 }
85813
85814
85815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85816   float jresult ;
85817   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85818   float arg2 ;
85819   float result;
85820
85821   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85822   arg2 = (float)jarg2;
85823   {
85824     try {
85825       result = (float)(arg1)->GetHeightForWidth(arg2);
85826     } catch (std::out_of_range& e) {
85827       {
85828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85829       };
85830     } catch (std::exception& e) {
85831       {
85832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85833       };
85834     } catch (Dali::DaliException e) {
85835       {
85836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85837       };
85838     } catch (...) {
85839       {
85840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85841       };
85842     }
85843   }
85844
85845   jresult = result;
85846   return jresult;
85847 }
85848
85849
85850 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85851   float jresult ;
85852   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85853   float arg2 ;
85854   float result;
85855
85856   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85857   arg2 = (float)jarg2;
85858   {
85859     try {
85860       result = (float)(arg1)->GetWidthForHeight(arg2);
85861     } catch (std::out_of_range& e) {
85862       {
85863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85864       };
85865     } catch (std::exception& e) {
85866       {
85867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85868       };
85869     } catch (Dali::DaliException e) {
85870       {
85871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85872       };
85873     } catch (...) {
85874       {
85875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85876       };
85877     }
85878   }
85879
85880   jresult = result;
85881   return jresult;
85882 }
85883
85884
85885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85886   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85887   Dali::Vector2 *arg2 = 0 ;
85888
85889   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85890   arg2 = (Dali::Vector2 *)jarg2;
85891   if (!arg2) {
85892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85893     return ;
85894   }
85895   {
85896     try {
85897       (arg1)->GetNaturalSize(*arg2);
85898     } catch (std::out_of_range& e) {
85899       {
85900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85901       };
85902     } catch (std::exception& e) {
85903       {
85904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85905       };
85906     } catch (Dali::DaliException e) {
85907       {
85908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85909       };
85910     } catch (...) {
85911       {
85912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85913       };
85914     }
85915   }
85916
85917 }
85918
85919
85920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
85921   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85922   float arg2 ;
85923
85924   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85925   arg2 = (int)jarg2;
85926   {
85927     try {
85928       (arg1)->SetDepthIndex(arg2);
85929     } catch (std::out_of_range& e) {
85930       {
85931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85932       };
85933     } catch (std::exception& e) {
85934       {
85935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85936       };
85937     } catch (Dali::DaliException e) {
85938       {
85939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85940       };
85941     } catch (...) {
85942       {
85943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85944       };
85945     }
85946   }
85947
85948 }
85949
85950
85951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85952   int jresult ;
85953   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85954   int result;
85955
85956   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85957   {
85958     try {
85959       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85960     } catch (std::out_of_range& e) {
85961       {
85962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85963       };
85964     } catch (std::exception& e) {
85965       {
85966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85967       };
85968     } catch (Dali::DaliException e) {
85969       {
85970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85971       };
85972     } catch (...) {
85973       {
85974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85975       };
85976     }
85977   }
85978
85979   jresult = result;
85980   return jresult;
85981 }
85982
85983
85984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85985   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85986   Dali::Property::Map *arg2 = 0 ;
85987
85988   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85989   arg2 = (Dali::Property::Map *)jarg2;
85990   if (!arg2) {
85991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85992     return ;
85993   }
85994   {
85995     try {
85996       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85997     } catch (std::out_of_range& e) {
85998       {
85999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86000       };
86001     } catch (std::exception& e) {
86002       {
86003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86004       };
86005     } catch (Dali::DaliException e) {
86006       {
86007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86008       };
86009     } catch (...) {
86010       {
86011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86012       };
86013     }
86014   }
86015
86016 }
86017
86018
86019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
86020   void * jresult ;
86021   Dali::Toolkit::VisualFactory result;
86022
86023   {
86024     try {
86025       result = Dali::Toolkit::VisualFactory::Get();
86026     } catch (std::out_of_range& e) {
86027       {
86028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86029       };
86030     } catch (std::exception& e) {
86031       {
86032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86033       };
86034     } catch (Dali::DaliException e) {
86035       {
86036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86037       };
86038     } catch (...) {
86039       {
86040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86041       };
86042     }
86043   }
86044
86045   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
86046   return jresult;
86047 }
86048
86049
86050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
86051   void * jresult ;
86052   Dali::Toolkit::VisualFactory *result = 0 ;
86053
86054   {
86055     try {
86056       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
86057     } catch (std::out_of_range& e) {
86058       {
86059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86060       };
86061     } catch (std::exception& e) {
86062       {
86063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86064       };
86065     } catch (Dali::DaliException e) {
86066       {
86067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86068       };
86069     } catch (...) {
86070       {
86071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86072       };
86073     }
86074   }
86075
86076   jresult = (void *)result;
86077   return jresult;
86078 }
86079
86080
86081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
86082   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86083
86084   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86085   {
86086     try {
86087       delete arg1;
86088     } catch (std::out_of_range& e) {
86089       {
86090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86091       };
86092     } catch (std::exception& e) {
86093       {
86094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86095       };
86096     } catch (Dali::DaliException e) {
86097       {
86098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86099       };
86100     } catch (...) {
86101       {
86102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86103       };
86104     }
86105   }
86106
86107 }
86108
86109
86110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
86111   void * jresult ;
86112   Dali::Toolkit::VisualFactory *arg1 = 0 ;
86113   Dali::Toolkit::VisualFactory *result = 0 ;
86114
86115   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86116   if (!arg1) {
86117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86118     return 0;
86119   }
86120   {
86121     try {
86122       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
86123     } catch (std::out_of_range& e) {
86124       {
86125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86126       };
86127     } catch (std::exception& e) {
86128       {
86129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86130       };
86131     } catch (Dali::DaliException e) {
86132       {
86133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86134       };
86135     } catch (...) {
86136       {
86137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86138       };
86139     }
86140   }
86141
86142   jresult = (void *)result;
86143   return jresult;
86144 }
86145
86146
86147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86148   void * jresult ;
86149   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86150   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86151   Dali::Toolkit::VisualFactory *result = 0 ;
86152
86153   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86154   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86155   if (!arg2) {
86156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86157     return 0;
86158   }
86159   {
86160     try {
86161       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86162     } catch (std::out_of_range& e) {
86163       {
86164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86165       };
86166     } catch (std::exception& e) {
86167       {
86168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86169       };
86170     } catch (Dali::DaliException e) {
86171       {
86172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86173       };
86174     } catch (...) {
86175       {
86176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86177       };
86178     }
86179   }
86180
86181   jresult = (void *)result;
86182   return jresult;
86183 }
86184
86185
86186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86187   void * jresult ;
86188   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86189   Dali::Property::Map *arg2 = 0 ;
86190   Dali::Toolkit::Visual::Base result;
86191
86192   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86193   arg2 = (Dali::Property::Map *)jarg2;
86194   if (!arg2) {
86195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86196     return 0;
86197   }
86198   {
86199     try {
86200       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86201     } catch (std::out_of_range& e) {
86202       {
86203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86204       };
86205     } catch (std::exception& e) {
86206       {
86207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86208       };
86209     } catch (Dali::DaliException e) {
86210       {
86211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86212       };
86213     } catch (...) {
86214       {
86215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86216       };
86217     }
86218   }
86219
86220   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86221   return jresult;
86222 }
86223
86224
86225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86226   void * jresult ;
86227   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86228   std::string *arg2 = 0 ;
86229   Dali::ImageDimensions arg3 ;
86230   Dali::ImageDimensions *argp3 ;
86231   Dali::Toolkit::Visual::Base result;
86232
86233   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86234   if (!jarg2) {
86235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86236     return 0;
86237   }
86238   std::string arg2_str(jarg2);
86239   arg2 = &arg2_str;
86240   argp3 = (Dali::ImageDimensions *)jarg3;
86241   if (!argp3) {
86242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86243     return 0;
86244   }
86245   arg3 = *argp3;
86246   {
86247     try {
86248       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86249     } catch (std::out_of_range& e) {
86250       {
86251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86252       };
86253     } catch (std::exception& e) {
86254       {
86255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86256       };
86257     } catch (Dali::DaliException e) {
86258       {
86259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86260       };
86261     } catch (...) {
86262       {
86263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86264       };
86265     }
86266   }
86267
86268   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86269
86270   //argout typemap for const std::string&
86271
86272   return jresult;
86273 }
86274
86275
86276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86277   void * jresult ;
86278   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86279
86280   {
86281     try {
86282       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86283     } catch (std::out_of_range& e) {
86284       {
86285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86286       };
86287     } catch (std::exception& e) {
86288       {
86289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86290       };
86291     } catch (Dali::DaliException e) {
86292       {
86293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86294       };
86295     } catch (...) {
86296       {
86297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86298       };
86299     }
86300   }
86301
86302   jresult = (void *)result;
86303   return jresult;
86304 }
86305
86306
86307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86308   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86309
86310   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86311   {
86312     try {
86313       delete arg1;
86314     } catch (std::out_of_range& e) {
86315       {
86316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86317       };
86318     } catch (std::exception& e) {
86319       {
86320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86321       };
86322     } catch (Dali::DaliException e) {
86323       {
86324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86325       };
86326     } catch (...) {
86327       {
86328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86329       };
86330     }
86331   }
86332
86333 }
86334
86335
86336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86337   void * jresult ;
86338   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86339   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86340
86341   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86342   if (!arg1) {
86343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86344     return 0;
86345   }
86346   {
86347     try {
86348       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86349     } catch (std::out_of_range& e) {
86350       {
86351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86352       };
86353     } catch (std::exception& e) {
86354       {
86355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86356       };
86357     } catch (Dali::DaliException e) {
86358       {
86359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86360       };
86361     } catch (...) {
86362       {
86363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86364       };
86365     }
86366   }
86367
86368   jresult = (void *)result;
86369   return jresult;
86370 }
86371
86372
86373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86374   void * jresult ;
86375   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86376   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86377   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86378
86379   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86380   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86381   if (!arg2) {
86382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86383     return 0;
86384   }
86385   {
86386     try {
86387       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86388     } catch (std::out_of_range& e) {
86389       {
86390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86391       };
86392     } catch (std::exception& e) {
86393       {
86394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86395       };
86396     } catch (Dali::DaliException e) {
86397       {
86398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86399       };
86400     } catch (...) {
86401       {
86402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86403       };
86404     }
86405   }
86406
86407   jresult = (void *)result;
86408   return jresult;
86409 }
86410
86411
86412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86413   void * jresult ;
86414   Dali::Toolkit::AsyncImageLoader result;
86415
86416   {
86417     try {
86418       result = Dali::Toolkit::AsyncImageLoader::New();
86419     } catch (std::out_of_range& e) {
86420       {
86421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86422       };
86423     } catch (std::exception& e) {
86424       {
86425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86426       };
86427     } catch (Dali::DaliException e) {
86428       {
86429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86430       };
86431     } catch (...) {
86432       {
86433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86434       };
86435     }
86436   }
86437
86438   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86439   return jresult;
86440 }
86441
86442
86443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86444   void * jresult ;
86445   Dali::BaseHandle arg1 ;
86446   Dali::BaseHandle *argp1 ;
86447   Dali::Toolkit::AsyncImageLoader result;
86448
86449   argp1 = (Dali::BaseHandle *)jarg1;
86450   if (!argp1) {
86451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86452     return 0;
86453   }
86454   arg1 = *argp1;
86455   {
86456     try {
86457       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86458     } catch (std::out_of_range& e) {
86459       {
86460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86461       };
86462     } catch (std::exception& e) {
86463       {
86464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86465       };
86466     } catch (Dali::DaliException e) {
86467       {
86468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86469       };
86470     } catch (...) {
86471       {
86472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86473       };
86474     }
86475   }
86476
86477   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86478   return jresult;
86479 }
86480
86481
86482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86483   unsigned int jresult ;
86484   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86485   std::string *arg2 = 0 ;
86486   uint32_t result;
86487
86488   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86489   if (!jarg2) {
86490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86491     return 0;
86492   }
86493   std::string arg2_str(jarg2);
86494   arg2 = &arg2_str;
86495   {
86496     try {
86497       result = (arg1)->Load((std::string const &)*arg2);
86498     } catch (std::out_of_range& e) {
86499       {
86500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86501       };
86502     } catch (std::exception& e) {
86503       {
86504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86505       };
86506     } catch (Dali::DaliException e) {
86507       {
86508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86509       };
86510     } catch (...) {
86511       {
86512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86513       };
86514     }
86515   }
86516
86517   jresult = result;
86518
86519   //argout typemap for const std::string&
86520
86521   return jresult;
86522 }
86523
86524
86525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86526   unsigned int jresult ;
86527   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86528   std::string *arg2 = 0 ;
86529   Dali::ImageDimensions arg3 ;
86530   Dali::ImageDimensions *argp3 ;
86531   uint32_t result;
86532
86533   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86534   if (!jarg2) {
86535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86536     return 0;
86537   }
86538   std::string arg2_str(jarg2);
86539   arg2 = &arg2_str;
86540   argp3 = (Dali::ImageDimensions *)jarg3;
86541   if (!argp3) {
86542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86543     return 0;
86544   }
86545   arg3 = *argp3;
86546   {
86547     try {
86548       result = (arg1)->Load((std::string const &)*arg2,arg3);
86549     } catch (std::out_of_range& e) {
86550       {
86551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86552       };
86553     } catch (std::exception& e) {
86554       {
86555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86556       };
86557     } catch (Dali::DaliException e) {
86558       {
86559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86560       };
86561     } catch (...) {
86562       {
86563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86564       };
86565     }
86566   }
86567
86568   jresult = result;
86569
86570   //argout typemap for const std::string&
86571
86572   return jresult;
86573 }
86574
86575
86576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86577   unsigned int jresult ;
86578   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86579   std::string *arg2 = 0 ;
86580   Dali::ImageDimensions arg3 ;
86581   Dali::FittingMode::Type arg4 ;
86582   Dali::SamplingMode::Type arg5 ;
86583   bool arg6 ;
86584   Dali::ImageDimensions *argp3 ;
86585   uint32_t result;
86586
86587   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86588   if (!jarg2) {
86589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86590     return 0;
86591   }
86592   std::string arg2_str(jarg2);
86593   arg2 = &arg2_str;
86594   argp3 = (Dali::ImageDimensions *)jarg3;
86595   if (!argp3) {
86596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86597     return 0;
86598   }
86599   arg3 = *argp3;
86600   arg4 = (Dali::FittingMode::Type)jarg4;
86601   arg5 = (Dali::SamplingMode::Type)jarg5;
86602   arg6 = jarg6 ? true : false;
86603   {
86604     try {
86605       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86606     } catch (std::out_of_range& e) {
86607       {
86608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86609       };
86610     } catch (std::exception& e) {
86611       {
86612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86613       };
86614     } catch (Dali::DaliException e) {
86615       {
86616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86617       };
86618     } catch (...) {
86619       {
86620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86621       };
86622     }
86623   }
86624
86625   jresult = result;
86626
86627   //argout typemap for const std::string&
86628
86629   return jresult;
86630 }
86631
86632
86633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86634   unsigned int jresult ;
86635   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86636   uint32_t arg2 ;
86637   bool result;
86638
86639   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86640   arg2 = (uint32_t)jarg2;
86641   {
86642     try {
86643       result = (bool)(arg1)->Cancel(arg2);
86644     } catch (std::out_of_range& e) {
86645       {
86646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86647       };
86648     } catch (std::exception& e) {
86649       {
86650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86651       };
86652     } catch (Dali::DaliException e) {
86653       {
86654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86655       };
86656     } catch (...) {
86657       {
86658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86659       };
86660     }
86661   }
86662
86663   jresult = result;
86664   return jresult;
86665 }
86666
86667
86668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86669   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86670
86671   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86672   {
86673     try {
86674       (arg1)->CancelAll();
86675     } catch (std::out_of_range& e) {
86676       {
86677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86678       };
86679     } catch (std::exception& e) {
86680       {
86681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86682       };
86683     } catch (Dali::DaliException e) {
86684       {
86685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86686       };
86687     } catch (...) {
86688       {
86689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86690       };
86691     }
86692   }
86693
86694 }
86695
86696
86697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86698   void * jresult ;
86699   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86700   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86701
86702   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86703   {
86704     try {
86705       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86706     } catch (std::out_of_range& e) {
86707       {
86708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86709       };
86710     } catch (std::exception& e) {
86711       {
86712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86713       };
86714     } catch (Dali::DaliException e) {
86715       {
86716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86717       };
86718     } catch (...) {
86719       {
86720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86721       };
86722     }
86723   }
86724
86725   jresult = (void *)result;
86726   return jresult;
86727 }
86728
86729
86730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86731   void * jresult ;
86732   std::string *arg1 = 0 ;
86733   Dali::PixelData result;
86734
86735   if (!jarg1) {
86736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86737     return 0;
86738   }
86739   std::string arg1_str(jarg1);
86740   arg1 = &arg1_str;
86741   {
86742     try {
86743       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86744     } catch (std::out_of_range& e) {
86745       {
86746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86747       };
86748     } catch (std::exception& e) {
86749       {
86750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86751       };
86752     } catch (Dali::DaliException e) {
86753       {
86754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86755       };
86756     } catch (...) {
86757       {
86758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86759       };
86760     }
86761   }
86762
86763   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86764
86765   //argout typemap for const std::string&
86766
86767   return jresult;
86768 }
86769
86770
86771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86772   void * jresult ;
86773   std::string *arg1 = 0 ;
86774   Dali::ImageDimensions arg2 ;
86775   Dali::ImageDimensions *argp2 ;
86776   Dali::PixelData result;
86777
86778   if (!jarg1) {
86779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86780     return 0;
86781   }
86782   std::string arg1_str(jarg1);
86783   arg1 = &arg1_str;
86784   argp2 = (Dali::ImageDimensions *)jarg2;
86785   if (!argp2) {
86786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86787     return 0;
86788   }
86789   arg2 = *argp2;
86790   {
86791     try {
86792       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86793     } catch (std::out_of_range& e) {
86794       {
86795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86796       };
86797     } catch (std::exception& e) {
86798       {
86799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86800       };
86801     } catch (Dali::DaliException e) {
86802       {
86803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86804       };
86805     } catch (...) {
86806       {
86807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86808       };
86809     }
86810   }
86811
86812   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86813
86814   //argout typemap for const std::string&
86815
86816   return jresult;
86817 }
86818
86819
86820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86821   void * jresult ;
86822   std::string *arg1 = 0 ;
86823   Dali::ImageDimensions arg2 ;
86824   Dali::FittingMode::Type arg3 ;
86825   Dali::SamplingMode::Type arg4 ;
86826   bool arg5 ;
86827   Dali::ImageDimensions *argp2 ;
86828   Dali::PixelData result;
86829
86830   if (!jarg1) {
86831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86832     return 0;
86833   }
86834   std::string arg1_str(jarg1);
86835   arg1 = &arg1_str;
86836   argp2 = (Dali::ImageDimensions *)jarg2;
86837   if (!argp2) {
86838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86839     return 0;
86840   }
86841   arg2 = *argp2;
86842   arg3 = (Dali::FittingMode::Type)jarg3;
86843   arg4 = (Dali::SamplingMode::Type)jarg4;
86844   arg5 = jarg5 ? true : false;
86845   {
86846     try {
86847       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86848     } catch (std::out_of_range& e) {
86849       {
86850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86851       };
86852     } catch (std::exception& e) {
86853       {
86854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86855       };
86856     } catch (Dali::DaliException e) {
86857       {
86858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86859       };
86860     } catch (...) {
86861       {
86862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86863       };
86864     }
86865   }
86866
86867   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86868
86869   //argout typemap for const std::string&
86870
86871   return jresult;
86872 }
86873
86874
86875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86876   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86877
86878   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86879   {
86880     try {
86881       delete arg1;
86882     } catch (std::out_of_range& e) {
86883       {
86884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86885       };
86886     } catch (std::exception& e) {
86887       {
86888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86889       };
86890     } catch (Dali::DaliException e) {
86891       {
86892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86893       };
86894     } catch (...) {
86895       {
86896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86897       };
86898     }
86899   }
86900
86901 }
86902
86903
86904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86905   void * jresult ;
86906   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86907   Dali::Actor arg2 ;
86908   Dali::Actor arg3 ;
86909   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86910   Dali::Actor *argp2 ;
86911   Dali::Actor *argp3 ;
86912   Dali::Actor result;
86913
86914   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86915   argp2 = (Dali::Actor *)jarg2;
86916   if (!argp2) {
86917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86918     return 0;
86919   }
86920   arg2 = *argp2;
86921   argp3 = (Dali::Actor *)jarg3;
86922   if (!argp3) {
86923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86924     return 0;
86925   }
86926   arg3 = *argp3;
86927   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86928   {
86929     try {
86930       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86931     } catch (std::out_of_range& e) {
86932       {
86933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86934       };
86935     } catch (std::exception& e) {
86936       {
86937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86938       };
86939     } catch (Dali::DaliException e) {
86940       {
86941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86942       };
86943     } catch (...) {
86944       {
86945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86946       };
86947     }
86948   }
86949
86950   jresult = new Dali::Actor((const Dali::Actor &)result);
86951   return jresult;
86952 }
86953
86954
86955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86956   void * jresult ;
86957   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86958
86959   {
86960     try {
86961       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86962     } catch (std::out_of_range& e) {
86963       {
86964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86965       };
86966     } catch (std::exception& e) {
86967       {
86968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86969       };
86970     } catch (Dali::DaliException e) {
86971       {
86972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86973       };
86974     } catch (...) {
86975       {
86976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86977       };
86978     }
86979   }
86980
86981   jresult = (void *)result;
86982   return jresult;
86983 }
86984
86985
86986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
86987   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
86988   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
86989   if (director) {
86990     director->swig_connect_director(callback0);
86991   }
86992 }
86993
86994
86995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
86996   void * jresult ;
86997   Dali::FrameCallbackInterface *result = 0 ;
86998
86999   {
87000     try {
87001       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
87002     } catch (std::out_of_range& e) {
87003       {
87004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87005       };
87006     } catch (std::exception& e) {
87007       {
87008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87009       };
87010     } catch (Dali::DaliException e) {
87011       {
87012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87013       };
87014     } catch (...) {
87015       {
87016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87017       };
87018     }
87019   }
87020
87021   jresult = (void *)result;
87022   return jresult;
87023 }
87024
87025 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
87026   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87027   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87028   return proxy->GetPosition(id, *vector3);
87029 }
87030
87031 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
87032   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87033   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87034   return proxy->SetPosition(id, *vector3);
87035 }
87036
87037 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
87038   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87039   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87040   return proxy->BakePosition(id, *vector3);
87041 }
87042
87043 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
87044   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87045   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87046   return proxy->GetSize(id, *vector3);
87047 }
87048
87049 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
87050   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87051   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87052   return proxy->SetSize(id, *vector3);
87053 }
87054 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
87055   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87056   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87057   return proxy->BakeSize(id, *vector3);
87058 }
87059
87060 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
87061   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87062   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
87063   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
87064   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
87065 }
87066
87067 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
87068   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87069   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87070   return proxy->GetScale(id,* vector3);
87071 }
87072
87073 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
87074   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87075   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87076   return proxy->SetScale(id, *vector3);
87077 }
87078
87079 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
87080   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87081   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87082   return proxy->BakeScale(id, *vector3);
87083 }
87084
87085 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
87086   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87087   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87088   return proxy->GetColor(id, *vector4);
87089 }
87090
87091 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
87092   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87093   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87094   return proxy->SetColor(id, *vector4);
87095 }
87096
87097 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
87098   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87099   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87100   return proxy->BakeColor(id, *vector4);
87101 }
87102
87103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
87104   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87105   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87106
87107   Dali::Stage *arg1 = (Dali::Stage *) 0;
87108   Dali::Actor *arg3 = 0;
87109
87110   arg1 = (Dali::Stage *)jarg1;
87111   arg3 = (Dali::Actor *)jarg3;
87112
87113   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
87114   return;
87115 }
87116
87117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
87118
87119   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87120   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87121
87122   Dali::Stage *arg1 = (Dali::Stage *) 0;
87123
87124   arg1 = (Dali::Stage *)jarg1;
87125
87126   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
87127   return;
87128 }
87129
87130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
87131   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
87132   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
87133   if (director) {
87134     director->swig_connect_director(callback0);
87135   }
87136 }
87137
87138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
87139   KeyboardFocusManager arg1 ;
87140   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
87141   KeyboardFocusManager *argp1 ;
87142
87143   argp1 = (KeyboardFocusManager *)jarg1;
87144   if (!argp1) {
87145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
87146     return ;
87147   }
87148   arg1 = *argp1;
87149   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
87150   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
87151   {
87152     try {
87153       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
87154     } catch (std::out_of_range& e) {
87155       {
87156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87157       };
87158     } catch (std::exception& e) {
87159       {
87160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87161       };
87162     } catch (Dali::DaliException e) {
87163       {
87164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87165       };
87166     } catch (...) {
87167       {
87168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87169       };
87170     }
87171   }
87172
87173 }
87174
87175
87176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
87177   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87178
87179   arg1 = (std::vector< unsigned int > *)jarg1;
87180   {
87181     try {
87182       (arg1)->clear();
87183     } catch (std::out_of_range& e) {
87184       {
87185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87186       };
87187     } catch (std::exception& e) {
87188       {
87189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87190       };
87191     } catch (Dali::DaliException e) {
87192       {
87193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87194       };
87195     } catch (...) {
87196       {
87197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87198       };
87199     }
87200   }
87201
87202 }
87203
87204
87205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87206   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87207   unsigned int *arg2 = 0 ;
87208   unsigned int temp2 ;
87209
87210   arg1 = (std::vector< unsigned int > *)jarg1;
87211   temp2 = (unsigned int)jarg2;
87212   arg2 = &temp2;
87213   {
87214     try {
87215       (arg1)->push_back((unsigned int const &)*arg2);
87216     } catch (std::out_of_range& e) {
87217       {
87218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87219       };
87220     } catch (std::exception& e) {
87221       {
87222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87223       };
87224     } catch (Dali::DaliException e) {
87225       {
87226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87227       };
87228     } catch (...) {
87229       {
87230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87231       };
87232     }
87233   }
87234
87235 }
87236
87237
87238 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87239   unsigned long jresult ;
87240   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87241   std::vector< unsigned int >::size_type result;
87242
87243   arg1 = (std::vector< unsigned int > *)jarg1;
87244   {
87245     try {
87246       result = ((std::vector< unsigned int > const *)arg1)->size();
87247     } catch (std::out_of_range& e) {
87248       {
87249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87250       };
87251     } catch (std::exception& e) {
87252       {
87253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87254       };
87255     } catch (Dali::DaliException e) {
87256       {
87257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87258       };
87259     } catch (...) {
87260       {
87261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87262       };
87263     }
87264   }
87265
87266   jresult = (unsigned long)result;
87267   return jresult;
87268 }
87269
87270
87271 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87272   unsigned long jresult ;
87273   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87274   std::vector< unsigned int >::size_type result;
87275
87276   arg1 = (std::vector< unsigned int > *)jarg1;
87277   {
87278     try {
87279       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87280     } catch (std::out_of_range& e) {
87281       {
87282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87283       };
87284     } catch (std::exception& e) {
87285       {
87286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87287       };
87288     } catch (Dali::DaliException e) {
87289       {
87290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87291       };
87292     } catch (...) {
87293       {
87294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87295       };
87296     }
87297   }
87298
87299   jresult = (unsigned long)result;
87300   return jresult;
87301 }
87302
87303
87304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87305   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87306   std::vector< unsigned int >::size_type arg2 ;
87307
87308   arg1 = (std::vector< unsigned int > *)jarg1;
87309   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87310   {
87311     try {
87312       (arg1)->reserve(arg2);
87313     } catch (std::out_of_range& e) {
87314       {
87315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87316       };
87317     } catch (std::exception& e) {
87318       {
87319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87320       };
87321     } catch (Dali::DaliException e) {
87322       {
87323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87324       };
87325     } catch (...) {
87326       {
87327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87328       };
87329     }
87330   }
87331
87332 }
87333
87334
87335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87336   void * jresult ;
87337   std::vector< unsigned int > *result = 0 ;
87338
87339   {
87340     try {
87341       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87342     } catch (std::out_of_range& e) {
87343       {
87344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87345       };
87346     } catch (std::exception& e) {
87347       {
87348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87349       };
87350     } catch (Dali::DaliException e) {
87351       {
87352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87353       };
87354     } catch (...) {
87355       {
87356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87357       };
87358     }
87359   }
87360
87361   jresult = (void *)result;
87362   return jresult;
87363 }
87364
87365
87366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87367   void * jresult ;
87368   std::vector< unsigned int > *arg1 = 0 ;
87369   std::vector< unsigned int > *result = 0 ;
87370
87371   arg1 = (std::vector< unsigned int > *)jarg1;
87372   if (!arg1) {
87373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87374     return 0;
87375   }
87376   {
87377     try {
87378       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87379     } catch (std::out_of_range& e) {
87380       {
87381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87382       };
87383     } catch (std::exception& e) {
87384       {
87385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87386       };
87387     } catch (Dali::DaliException e) {
87388       {
87389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87390       };
87391     } catch (...) {
87392       {
87393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87394       };
87395     }
87396   }
87397
87398   jresult = (void *)result;
87399   return jresult;
87400 }
87401
87402
87403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87404   void * jresult ;
87405   int arg1 ;
87406   std::vector< unsigned int > *result = 0 ;
87407
87408   arg1 = (int)jarg1;
87409   {
87410     try {
87411       try {
87412         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87413       }
87414       catch(std::out_of_range &_e) {
87415         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87416         return 0;
87417       }
87418
87419     } catch (std::out_of_range& e) {
87420       {
87421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87422       };
87423     } catch (std::exception& e) {
87424       {
87425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87426       };
87427     } catch (Dali::DaliException e) {
87428       {
87429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87430       };
87431     } catch (...) {
87432       {
87433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87434       };
87435     }
87436   }
87437
87438   jresult = (void *)result;
87439   return jresult;
87440 }
87441
87442
87443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87444   unsigned int jresult ;
87445   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87446   int arg2 ;
87447   unsigned int result;
87448
87449   arg1 = (std::vector< unsigned int > *)jarg1;
87450   arg2 = (int)jarg2;
87451   {
87452     try {
87453       try {
87454         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87455       }
87456       catch(std::out_of_range &_e) {
87457         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87458         return 0;
87459       }
87460
87461     } catch (std::out_of_range& e) {
87462       {
87463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87464       };
87465     } catch (std::exception& e) {
87466       {
87467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87468       };
87469     } catch (Dali::DaliException e) {
87470       {
87471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87472       };
87473     } catch (...) {
87474       {
87475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87476       };
87477     }
87478   }
87479
87480   jresult = result;
87481   return jresult;
87482 }
87483
87484
87485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87486   unsigned int jresult ;
87487   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87488   int arg2 ;
87489   unsigned int *result = 0 ;
87490
87491   arg1 = (std::vector< unsigned int > *)jarg1;
87492   arg2 = (int)jarg2;
87493   {
87494     try {
87495       try {
87496         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87497       }
87498       catch(std::out_of_range &_e) {
87499         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87500         return 0;
87501       }
87502
87503     } catch (std::out_of_range& e) {
87504       {
87505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87506       };
87507     } catch (std::exception& e) {
87508       {
87509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87510       };
87511     } catch (Dali::DaliException e) {
87512       {
87513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87514       };
87515     } catch (...) {
87516       {
87517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87518       };
87519     }
87520   }
87521
87522   jresult = *result;
87523   return jresult;
87524 }
87525
87526
87527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87528   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87529   int arg2 ;
87530   unsigned int *arg3 = 0 ;
87531   unsigned int temp3 ;
87532
87533   arg1 = (std::vector< unsigned int > *)jarg1;
87534   arg2 = (int)jarg2;
87535   temp3 = (unsigned int)jarg3;
87536   arg3 = &temp3;
87537   {
87538     try {
87539       try {
87540         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87541       }
87542       catch(std::out_of_range &_e) {
87543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87544         return ;
87545       }
87546
87547     } catch (std::out_of_range& e) {
87548       {
87549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87550       };
87551     } catch (std::exception& e) {
87552       {
87553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87554       };
87555     } catch (Dali::DaliException e) {
87556       {
87557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87558       };
87559     } catch (...) {
87560       {
87561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87562       };
87563     }
87564   }
87565
87566 }
87567
87568
87569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87570   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87571   std::vector< unsigned int > *arg2 = 0 ;
87572
87573   arg1 = (std::vector< unsigned int > *)jarg1;
87574   arg2 = (std::vector< unsigned int > *)jarg2;
87575   if (!arg2) {
87576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87577     return ;
87578   }
87579   {
87580     try {
87581       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87582     } catch (std::out_of_range& e) {
87583       {
87584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87585       };
87586     } catch (std::exception& e) {
87587       {
87588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87589       };
87590     } catch (Dali::DaliException e) {
87591       {
87592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87593       };
87594     } catch (...) {
87595       {
87596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87597       };
87598     }
87599   }
87600
87601 }
87602
87603
87604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87605   void * jresult ;
87606   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87607   int arg2 ;
87608   int arg3 ;
87609   std::vector< unsigned int > *result = 0 ;
87610
87611   arg1 = (std::vector< unsigned int > *)jarg1;
87612   arg2 = (int)jarg2;
87613   arg3 = (int)jarg3;
87614   {
87615     try {
87616       try {
87617         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87618       }
87619       catch(std::out_of_range &_e) {
87620         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87621         return 0;
87622       }
87623       catch(std::invalid_argument &_e) {
87624         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87625         return 0;
87626       }
87627
87628     } catch (std::out_of_range& e) {
87629       {
87630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87631       };
87632     } catch (std::exception& e) {
87633       {
87634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87635       };
87636     } catch (Dali::DaliException e) {
87637       {
87638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87639       };
87640     } catch (...) {
87641       {
87642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87643       };
87644     }
87645   }
87646
87647   jresult = (void *)result;
87648   return jresult;
87649 }
87650
87651
87652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87653   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87654   int arg2 ;
87655   unsigned int *arg3 = 0 ;
87656   unsigned int temp3 ;
87657
87658   arg1 = (std::vector< unsigned int > *)jarg1;
87659   arg2 = (int)jarg2;
87660   temp3 = (unsigned int)jarg3;
87661   arg3 = &temp3;
87662   {
87663     try {
87664       try {
87665         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87666       }
87667       catch(std::out_of_range &_e) {
87668         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87669         return ;
87670       }
87671
87672     } catch (std::out_of_range& e) {
87673       {
87674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87675       };
87676     } catch (std::exception& e) {
87677       {
87678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87679       };
87680     } catch (Dali::DaliException e) {
87681       {
87682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87683       };
87684     } catch (...) {
87685       {
87686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87687       };
87688     }
87689   }
87690
87691 }
87692
87693
87694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87695   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87696   int arg2 ;
87697   std::vector< unsigned int > *arg3 = 0 ;
87698
87699   arg1 = (std::vector< unsigned int > *)jarg1;
87700   arg2 = (int)jarg2;
87701   arg3 = (std::vector< unsigned int > *)jarg3;
87702   if (!arg3) {
87703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87704     return ;
87705   }
87706   {
87707     try {
87708       try {
87709         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87710       }
87711       catch(std::out_of_range &_e) {
87712         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87713         return ;
87714       }
87715
87716     } catch (std::out_of_range& e) {
87717       {
87718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87719       };
87720     } catch (std::exception& e) {
87721       {
87722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87723       };
87724     } catch (Dali::DaliException e) {
87725       {
87726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87727       };
87728     } catch (...) {
87729       {
87730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87731       };
87732     }
87733   }
87734
87735 }
87736
87737
87738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87739   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87740   int arg2 ;
87741
87742   arg1 = (std::vector< unsigned int > *)jarg1;
87743   arg2 = (int)jarg2;
87744   {
87745     try {
87746       try {
87747         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87748       }
87749       catch(std::out_of_range &_e) {
87750         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87751         return ;
87752       }
87753
87754     } catch (std::out_of_range& e) {
87755       {
87756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87757       };
87758     } catch (std::exception& e) {
87759       {
87760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87761       };
87762     } catch (Dali::DaliException e) {
87763       {
87764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87765       };
87766     } catch (...) {
87767       {
87768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87769       };
87770     }
87771   }
87772
87773 }
87774
87775
87776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87777   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87778   int arg2 ;
87779   int arg3 ;
87780
87781   arg1 = (std::vector< unsigned int > *)jarg1;
87782   arg2 = (int)jarg2;
87783   arg3 = (int)jarg3;
87784   {
87785     try {
87786       try {
87787         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87788       }
87789       catch(std::out_of_range &_e) {
87790         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87791         return ;
87792       }
87793       catch(std::invalid_argument &_e) {
87794         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87795         return ;
87796       }
87797
87798     } catch (std::out_of_range& e) {
87799       {
87800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87801       };
87802     } catch (std::exception& e) {
87803       {
87804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87805       };
87806     } catch (Dali::DaliException e) {
87807       {
87808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87809       };
87810     } catch (...) {
87811       {
87812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87813       };
87814     }
87815   }
87816
87817 }
87818
87819
87820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87821   void * jresult ;
87822   unsigned int *arg1 = 0 ;
87823   int arg2 ;
87824   unsigned int temp1 ;
87825   std::vector< unsigned int > *result = 0 ;
87826
87827   temp1 = (unsigned int)jarg1;
87828   arg1 = &temp1;
87829   arg2 = (int)jarg2;
87830   {
87831     try {
87832       try {
87833         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87834       }
87835       catch(std::out_of_range &_e) {
87836         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87837         return 0;
87838       }
87839
87840     } catch (std::out_of_range& e) {
87841       {
87842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87843       };
87844     } catch (std::exception& e) {
87845       {
87846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87847       };
87848     } catch (Dali::DaliException e) {
87849       {
87850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87851       };
87852     } catch (...) {
87853       {
87854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87855       };
87856     }
87857   }
87858
87859   jresult = (void *)result;
87860   return jresult;
87861 }
87862
87863
87864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87865   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87866
87867   arg1 = (std::vector< unsigned int > *)jarg1;
87868   {
87869     try {
87870       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87871     } catch (std::out_of_range& e) {
87872       {
87873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87874       };
87875     } catch (std::exception& e) {
87876       {
87877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87878       };
87879     } catch (Dali::DaliException e) {
87880       {
87881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87882       };
87883     } catch (...) {
87884       {
87885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87886       };
87887     }
87888   }
87889
87890 }
87891
87892
87893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87894   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87895   int arg2 ;
87896   int arg3 ;
87897
87898   arg1 = (std::vector< unsigned int > *)jarg1;
87899   arg2 = (int)jarg2;
87900   arg3 = (int)jarg3;
87901   {
87902     try {
87903       try {
87904         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87905       }
87906       catch(std::out_of_range &_e) {
87907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87908         return ;
87909       }
87910       catch(std::invalid_argument &_e) {
87911         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87912         return ;
87913       }
87914
87915     } catch (std::out_of_range& e) {
87916       {
87917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87918       };
87919     } catch (std::exception& e) {
87920       {
87921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87922       };
87923     } catch (Dali::DaliException e) {
87924       {
87925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87926       };
87927     } catch (...) {
87928       {
87929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87930       };
87931     }
87932   }
87933
87934 }
87935
87936
87937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87938   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87939   int arg2 ;
87940   std::vector< unsigned int > *arg3 = 0 ;
87941
87942   arg1 = (std::vector< unsigned int > *)jarg1;
87943   arg2 = (int)jarg2;
87944   arg3 = (std::vector< unsigned int > *)jarg3;
87945   if (!arg3) {
87946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87947     return ;
87948   }
87949   {
87950     try {
87951       try {
87952         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87953       }
87954       catch(std::out_of_range &_e) {
87955         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87956         return ;
87957       }
87958
87959     } catch (std::out_of_range& e) {
87960       {
87961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87962       };
87963     } catch (std::exception& e) {
87964       {
87965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87966       };
87967     } catch (Dali::DaliException e) {
87968       {
87969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87970       };
87971     } catch (...) {
87972       {
87973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87974       };
87975     }
87976   }
87977
87978 }
87979
87980
87981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87982   unsigned int jresult ;
87983   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87984   unsigned int *arg2 = 0 ;
87985   unsigned int temp2 ;
87986   bool result;
87987
87988   arg1 = (std::vector< unsigned int > *)jarg1;
87989   temp2 = (unsigned int)jarg2;
87990   arg2 = &temp2;
87991   {
87992     try {
87993       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87994     } catch (std::out_of_range& e) {
87995       {
87996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87997       };
87998     } catch (std::exception& e) {
87999       {
88000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88001       };
88002     } catch (Dali::DaliException e) {
88003       {
88004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88005       };
88006     } catch (...) {
88007       {
88008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88009       };
88010     }
88011   }
88012
88013   jresult = result;
88014   return jresult;
88015 }
88016
88017
88018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
88019   int jresult ;
88020   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88021   unsigned int *arg2 = 0 ;
88022   unsigned int temp2 ;
88023   int result;
88024
88025   arg1 = (std::vector< unsigned int > *)jarg1;
88026   temp2 = (unsigned int)jarg2;
88027   arg2 = &temp2;
88028   {
88029     try {
88030       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
88031     } catch (std::out_of_range& e) {
88032       {
88033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88034       };
88035     } catch (std::exception& e) {
88036       {
88037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88038       };
88039     } catch (Dali::DaliException e) {
88040       {
88041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88042       };
88043     } catch (...) {
88044       {
88045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88046       };
88047     }
88048   }
88049
88050   jresult = result;
88051   return jresult;
88052 }
88053
88054
88055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
88056   int jresult ;
88057   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88058   unsigned int *arg2 = 0 ;
88059   unsigned int temp2 ;
88060   int result;
88061
88062   arg1 = (std::vector< unsigned int > *)jarg1;
88063   temp2 = (unsigned int)jarg2;
88064   arg2 = &temp2;
88065   {
88066     try {
88067       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
88068     } catch (std::out_of_range& e) {
88069       {
88070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88071       };
88072     } catch (std::exception& e) {
88073       {
88074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88075       };
88076     } catch (Dali::DaliException e) {
88077       {
88078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88079       };
88080     } catch (...) {
88081       {
88082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88083       };
88084     }
88085   }
88086
88087   jresult = result;
88088   return jresult;
88089 }
88090
88091
88092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
88093   unsigned int jresult ;
88094   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88095   unsigned int *arg2 = 0 ;
88096   unsigned int temp2 ;
88097   bool result;
88098
88099   arg1 = (std::vector< unsigned int > *)jarg1;
88100   temp2 = (unsigned int)jarg2;
88101   arg2 = &temp2;
88102   {
88103     try {
88104       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
88105     } catch (std::out_of_range& e) {
88106       {
88107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88108       };
88109     } catch (std::exception& e) {
88110       {
88111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88112       };
88113     } catch (Dali::DaliException e) {
88114       {
88115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88116       };
88117     } catch (...) {
88118       {
88119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88120       };
88121     }
88122   }
88123
88124   jresult = result;
88125   return jresult;
88126 }
88127
88128
88129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
88130   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88131
88132   arg1 = (std::vector< unsigned int > *)jarg1;
88133   {
88134     try {
88135       delete arg1;
88136     } catch (std::out_of_range& e) {
88137       {
88138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88139       };
88140     } catch (std::exception& e) {
88141       {
88142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88143       };
88144     } catch (Dali::DaliException e) {
88145       {
88146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88147       };
88148     } catch (...) {
88149       {
88150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88151       };
88152     }
88153   }
88154
88155 }
88156
88157
88158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
88159   void * jresult ;
88160   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88161
88162   {
88163     try {
88164       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
88165     } catch (std::out_of_range& e) {
88166       {
88167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88168       };
88169     } catch (std::exception& e) {
88170       {
88171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88172       };
88173     } catch (Dali::DaliException e) {
88174       {
88175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88176       };
88177     } catch (...) {
88178       {
88179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88180       };
88181     }
88182   }
88183
88184   jresult = (void *)result;
88185   return jresult;
88186 }
88187
88188
88189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88190   void * jresult ;
88191   unsigned int arg1 ;
88192   Dali::Actor arg2 ;
88193   Dali::Actor *argp2 ;
88194   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88195
88196   arg1 = (unsigned int)jarg1;
88197   argp2 = (Dali::Actor *)jarg2;
88198   if (!argp2) {
88199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88200     return 0;
88201   }
88202   arg2 = *argp2;
88203   {
88204     try {
88205       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
88206     } catch (std::out_of_range& e) {
88207       {
88208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88209       };
88210     } catch (std::exception& e) {
88211       {
88212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88213       };
88214     } catch (Dali::DaliException e) {
88215       {
88216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88217       };
88218     } catch (...) {
88219       {
88220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88221       };
88222     }
88223   }
88224
88225   jresult = (void *)result;
88226   return jresult;
88227 }
88228
88229
88230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88231   void * jresult ;
88232   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88233   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88234
88235   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88236   if (!arg1) {
88237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88238     return 0;
88239   }
88240   {
88241     try {
88242       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88243     } catch (std::out_of_range& e) {
88244       {
88245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88246       };
88247     } catch (std::exception& e) {
88248       {
88249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88250       };
88251     } catch (Dali::DaliException e) {
88252       {
88253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88254       };
88255     } catch (...) {
88256       {
88257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88258       };
88259     }
88260   }
88261
88262   jresult = (void *)result;
88263   return jresult;
88264 }
88265
88266
88267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88268   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88269   unsigned int arg2 ;
88270
88271   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88272   arg2 = (unsigned int)jarg2;
88273   if (arg1) (arg1)->first = arg2;
88274 }
88275
88276
88277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88278   unsigned int jresult ;
88279   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88280   unsigned int result;
88281
88282   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88283   result = (unsigned int) ((arg1)->first);
88284   jresult = result;
88285   return jresult;
88286 }
88287
88288
88289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88290   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88291   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88292
88293   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88294   arg2 = (Dali::Actor *)jarg2;
88295   if (arg1) (arg1)->second = *arg2;
88296 }
88297
88298
88299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88300   void * jresult ;
88301   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88302   Dali::Actor *result = 0 ;
88303
88304   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88305   result = (Dali::Actor *)& ((arg1)->second);
88306   jresult = (void *)result;
88307   return jresult;
88308 }
88309
88310
88311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88312   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88313
88314   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88315   {
88316     try {
88317       delete arg1;
88318     } catch (std::out_of_range& e) {
88319       {
88320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88321       };
88322     } catch (std::exception& e) {
88323       {
88324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88325       };
88326     } catch (Dali::DaliException e) {
88327       {
88328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88329       };
88330     } catch (...) {
88331       {
88332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88333       };
88334     }
88335   }
88336
88337 }
88338
88339
88340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88341   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88342
88343   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88344   {
88345     try {
88346       (arg1)->clear();
88347     } catch (std::out_of_range& e) {
88348       {
88349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88350       };
88351     } catch (std::exception& e) {
88352       {
88353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88354       };
88355     } catch (Dali::DaliException e) {
88356       {
88357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88358       };
88359     } catch (...) {
88360       {
88361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88362       };
88363     }
88364   }
88365
88366 }
88367
88368
88369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88370   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88371   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88372
88373   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88374   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88375   if (!arg2) {
88376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88377     return ;
88378   }
88379   {
88380     try {
88381       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88382     } catch (std::out_of_range& e) {
88383       {
88384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88385       };
88386     } catch (std::exception& e) {
88387       {
88388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88389       };
88390     } catch (Dali::DaliException e) {
88391       {
88392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88393       };
88394     } catch (...) {
88395       {
88396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88397       };
88398     }
88399   }
88400
88401 }
88402
88403
88404 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88405   unsigned long jresult ;
88406   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88407   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88408
88409   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88410   {
88411     try {
88412       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
88413     } catch (std::out_of_range& e) {
88414       {
88415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88416       };
88417     } catch (std::exception& e) {
88418       {
88419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88420       };
88421     } catch (Dali::DaliException e) {
88422       {
88423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88424       };
88425     } catch (...) {
88426       {
88427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88428       };
88429     }
88430   }
88431
88432   jresult = (unsigned long)result;
88433   return jresult;
88434 }
88435
88436
88437 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88438   unsigned long jresult ;
88439   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88440   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88441
88442   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88443   {
88444     try {
88445       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88446     } catch (std::out_of_range& e) {
88447       {
88448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88449       };
88450     } catch (std::exception& e) {
88451       {
88452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88453       };
88454     } catch (Dali::DaliException e) {
88455       {
88456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88457       };
88458     } catch (...) {
88459       {
88460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88461       };
88462     }
88463   }
88464
88465   jresult = (unsigned long)result;
88466   return jresult;
88467 }
88468
88469
88470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88471   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88472   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88473
88474   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88475   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88476   {
88477     try {
88478       (arg1)->reserve(arg2);
88479     } catch (std::out_of_range& e) {
88480       {
88481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88482       };
88483     } catch (std::exception& e) {
88484       {
88485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88486       };
88487     } catch (Dali::DaliException e) {
88488       {
88489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88490       };
88491     } catch (...) {
88492       {
88493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88494       };
88495     }
88496   }
88497
88498 }
88499
88500
88501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88502   void * jresult ;
88503   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88504
88505   {
88506     try {
88507       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88508     } catch (std::out_of_range& e) {
88509       {
88510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88511       };
88512     } catch (std::exception& e) {
88513       {
88514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88515       };
88516     } catch (Dali::DaliException e) {
88517       {
88518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88519       };
88520     } catch (...) {
88521       {
88522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88523       };
88524     }
88525   }
88526
88527   jresult = (void *)result;
88528   return jresult;
88529 }
88530
88531
88532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88533   void * jresult ;
88534   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88535   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88536
88537   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88538   if (!arg1) {
88539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88540     return 0;
88541   }
88542   {
88543     try {
88544       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);
88545     } catch (std::out_of_range& e) {
88546       {
88547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88548       };
88549     } catch (std::exception& e) {
88550       {
88551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88552       };
88553     } catch (Dali::DaliException e) {
88554       {
88555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88556       };
88557     } catch (...) {
88558       {
88559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88560       };
88561     }
88562   }
88563
88564   jresult = (void *)result;
88565   return jresult;
88566 }
88567
88568
88569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88570   void * jresult ;
88571   int arg1 ;
88572   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88573
88574   arg1 = (int)jarg1;
88575   {
88576     try {
88577       try {
88578         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);
88579       }
88580       catch(std::out_of_range &_e) {
88581         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88582         return 0;
88583       }
88584
88585     } catch (std::out_of_range& e) {
88586       {
88587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88588       };
88589     } catch (std::exception& e) {
88590       {
88591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88592       };
88593     } catch (Dali::DaliException e) {
88594       {
88595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88596       };
88597     } catch (...) {
88598       {
88599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88600       };
88601     }
88602   }
88603
88604   jresult = (void *)result;
88605   return jresult;
88606 }
88607
88608
88609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88610   void * jresult ;
88611   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88612   int arg2 ;
88613   std::pair< unsigned int,Dali::Actor > result;
88614
88615   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88616   arg2 = (int)jarg2;
88617   {
88618     try {
88619       try {
88620         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88621       }
88622       catch(std::out_of_range &_e) {
88623         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88624         return 0;
88625       }
88626
88627     } catch (std::out_of_range& e) {
88628       {
88629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88630       };
88631     } catch (std::exception& e) {
88632       {
88633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88634       };
88635     } catch (Dali::DaliException e) {
88636       {
88637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88638       };
88639     } catch (...) {
88640       {
88641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88642       };
88643     }
88644   }
88645
88646   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88647   return jresult;
88648 }
88649
88650
88651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88652   void * jresult ;
88653   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88654   int arg2 ;
88655   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88656
88657   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88658   arg2 = (int)jarg2;
88659   {
88660     try {
88661       try {
88662         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88663       }
88664       catch(std::out_of_range &_e) {
88665         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88666         return 0;
88667       }
88668
88669     } catch (std::out_of_range& e) {
88670       {
88671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88672       };
88673     } catch (std::exception& e) {
88674       {
88675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88676       };
88677     } catch (Dali::DaliException e) {
88678       {
88679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88680       };
88681     } catch (...) {
88682       {
88683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88684       };
88685     }
88686   }
88687
88688   jresult = (void *)result;
88689   return jresult;
88690 }
88691
88692
88693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88694   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88695   int arg2 ;
88696   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88697
88698   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88699   arg2 = (int)jarg2;
88700   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88701   if (!arg3) {
88702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88703     return ;
88704   }
88705   {
88706     try {
88707       try {
88708         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);
88709       }
88710       catch(std::out_of_range &_e) {
88711         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88712         return ;
88713       }
88714
88715     } catch (std::out_of_range& e) {
88716       {
88717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88718       };
88719     } catch (std::exception& e) {
88720       {
88721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88722       };
88723     } catch (Dali::DaliException e) {
88724       {
88725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88726       };
88727     } catch (...) {
88728       {
88729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88730       };
88731     }
88732   }
88733
88734 }
88735
88736
88737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88738   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88739   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88740
88741   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88742   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88743   if (!arg2) {
88744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88745     return ;
88746   }
88747   {
88748     try {
88749       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);
88750     } catch (std::out_of_range& e) {
88751       {
88752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88753       };
88754     } catch (std::exception& e) {
88755       {
88756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88757       };
88758     } catch (Dali::DaliException e) {
88759       {
88760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88761       };
88762     } catch (...) {
88763       {
88764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88765       };
88766     }
88767   }
88768
88769 }
88770
88771
88772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88773   void * jresult ;
88774   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88775   int arg2 ;
88776   int arg3 ;
88777   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88778
88779   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88780   arg2 = (int)jarg2;
88781   arg3 = (int)jarg3;
88782   {
88783     try {
88784       try {
88785         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);
88786       }
88787       catch(std::out_of_range &_e) {
88788         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88789         return 0;
88790       }
88791       catch(std::invalid_argument &_e) {
88792         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88793         return 0;
88794       }
88795
88796     } catch (std::out_of_range& e) {
88797       {
88798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88799       };
88800     } catch (std::exception& e) {
88801       {
88802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88803       };
88804     } catch (Dali::DaliException e) {
88805       {
88806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88807       };
88808     } catch (...) {
88809       {
88810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88811       };
88812     }
88813   }
88814
88815   jresult = (void *)result;
88816   return jresult;
88817 }
88818
88819
88820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88821   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88822   int arg2 ;
88823   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88824
88825   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88826   arg2 = (int)jarg2;
88827   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88828   if (!arg3) {
88829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88830     return ;
88831   }
88832   {
88833     try {
88834       try {
88835         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);
88836       }
88837       catch(std::out_of_range &_e) {
88838         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88839         return ;
88840       }
88841
88842     } catch (std::out_of_range& e) {
88843       {
88844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88845       };
88846     } catch (std::exception& e) {
88847       {
88848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88849       };
88850     } catch (Dali::DaliException e) {
88851       {
88852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88853       };
88854     } catch (...) {
88855       {
88856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88857       };
88858     }
88859   }
88860
88861 }
88862
88863
88864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88865   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88866   int arg2 ;
88867   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88868
88869   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88870   arg2 = (int)jarg2;
88871   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88872   if (!arg3) {
88873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88874     return ;
88875   }
88876   {
88877     try {
88878       try {
88879         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);
88880       }
88881       catch(std::out_of_range &_e) {
88882         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88883         return ;
88884       }
88885
88886     } catch (std::out_of_range& e) {
88887       {
88888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88889       };
88890     } catch (std::exception& e) {
88891       {
88892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88893       };
88894     } catch (Dali::DaliException e) {
88895       {
88896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88897       };
88898     } catch (...) {
88899       {
88900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88901       };
88902     }
88903   }
88904
88905 }
88906
88907
88908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88909   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88910   int arg2 ;
88911
88912   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88913   arg2 = (int)jarg2;
88914   {
88915     try {
88916       try {
88917         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88918       }
88919       catch(std::out_of_range &_e) {
88920         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88921         return ;
88922       }
88923
88924     } catch (std::out_of_range& e) {
88925       {
88926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88927       };
88928     } catch (std::exception& e) {
88929       {
88930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88931       };
88932     } catch (Dali::DaliException e) {
88933       {
88934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88935       };
88936     } catch (...) {
88937       {
88938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88939       };
88940     }
88941   }
88942
88943 }
88944
88945
88946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88947   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88948   int arg2 ;
88949   int arg3 ;
88950
88951   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88952   arg2 = (int)jarg2;
88953   arg3 = (int)jarg3;
88954   {
88955     try {
88956       try {
88957         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88958       }
88959       catch(std::out_of_range &_e) {
88960         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88961         return ;
88962       }
88963       catch(std::invalid_argument &_e) {
88964         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88965         return ;
88966       }
88967
88968     } catch (std::out_of_range& e) {
88969       {
88970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88971       };
88972     } catch (std::exception& e) {
88973       {
88974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88975       };
88976     } catch (Dali::DaliException e) {
88977       {
88978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88979       };
88980     } catch (...) {
88981       {
88982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88983       };
88984     }
88985   }
88986
88987 }
88988
88989
88990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88991   void * jresult ;
88992   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88993   int arg2 ;
88994   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88995
88996   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88997   if (!arg1) {
88998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88999     return 0;
89000   }
89001   arg2 = (int)jarg2;
89002   {
89003     try {
89004       try {
89005         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);
89006       }
89007       catch(std::out_of_range &_e) {
89008         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89009         return 0;
89010       }
89011
89012     } catch (std::out_of_range& e) {
89013       {
89014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89015       };
89016     } catch (std::exception& e) {
89017       {
89018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89019       };
89020     } catch (Dali::DaliException e) {
89021       {
89022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89023       };
89024     } catch (...) {
89025       {
89026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89027       };
89028     }
89029   }
89030
89031   jresult = (void *)result;
89032   return jresult;
89033 }
89034
89035
89036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
89037   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89038
89039   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89040   {
89041     try {
89042       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
89043     } catch (std::out_of_range& e) {
89044       {
89045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89046       };
89047     } catch (std::exception& e) {
89048       {
89049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89050       };
89051     } catch (Dali::DaliException e) {
89052       {
89053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89054       };
89055     } catch (...) {
89056       {
89057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89058       };
89059     }
89060   }
89061
89062 }
89063
89064
89065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89066   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89067   int arg2 ;
89068   int arg3 ;
89069
89070   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89071   arg2 = (int)jarg2;
89072   arg3 = (int)jarg3;
89073   {
89074     try {
89075       try {
89076         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89077       }
89078       catch(std::out_of_range &_e) {
89079         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89080         return ;
89081       }
89082       catch(std::invalid_argument &_e) {
89083         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89084         return ;
89085       }
89086
89087     } catch (std::out_of_range& e) {
89088       {
89089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89090       };
89091     } catch (std::exception& e) {
89092       {
89093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89094       };
89095     } catch (Dali::DaliException e) {
89096       {
89097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89098       };
89099     } catch (...) {
89100       {
89101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89102       };
89103     }
89104   }
89105
89106 }
89107
89108
89109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89110   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89111   int arg2 ;
89112   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89113
89114   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89115   arg2 = (int)jarg2;
89116   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89117   if (!arg3) {
89118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89119     return ;
89120   }
89121   {
89122     try {
89123       try {
89124         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);
89125       }
89126       catch(std::out_of_range &_e) {
89127         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89128         return ;
89129       }
89130
89131     } catch (std::out_of_range& e) {
89132       {
89133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89134       };
89135     } catch (std::exception& e) {
89136       {
89137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89138       };
89139     } catch (Dali::DaliException e) {
89140       {
89141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89142       };
89143     } catch (...) {
89144       {
89145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89146       };
89147     }
89148   }
89149
89150 }
89151
89152
89153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
89154   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89155
89156   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89157   {
89158     try {
89159       delete arg1;
89160     } catch (std::out_of_range& e) {
89161       {
89162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89163       };
89164     } catch (std::exception& e) {
89165       {
89166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89167       };
89168     } catch (Dali::DaliException e) {
89169       {
89170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89171       };
89172     } catch (...) {
89173       {
89174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89175       };
89176     }
89177   }
89178
89179 }
89180
89181
89182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89183   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89184
89185   arg1 = (std::vector< Dali::Actor > *)jarg1;
89186   {
89187     try {
89188       (arg1)->clear();
89189     } catch (std::out_of_range& e) {
89190       {
89191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89192       };
89193     } catch (std::exception& e) {
89194       {
89195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89196       };
89197     } catch (Dali::DaliException e) {
89198       {
89199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89200       };
89201     } catch (...) {
89202       {
89203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89204       };
89205     }
89206   }
89207
89208 }
89209
89210
89211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89212   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89213   Dali::Actor *arg2 = 0 ;
89214
89215   arg1 = (std::vector< Dali::Actor > *)jarg1;
89216   arg2 = (Dali::Actor *)jarg2;
89217   if (!arg2) {
89218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89219     return ;
89220   }
89221   {
89222     try {
89223       (arg1)->push_back((Dali::Actor const &)*arg2);
89224     } catch (std::out_of_range& e) {
89225       {
89226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89227       };
89228     } catch (std::exception& e) {
89229       {
89230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89231       };
89232     } catch (Dali::DaliException e) {
89233       {
89234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89235       };
89236     } catch (...) {
89237       {
89238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89239       };
89240     }
89241   }
89242
89243 }
89244
89245
89246 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89247   unsigned long jresult ;
89248   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89249   std::vector< Dali::Actor >::size_type result;
89250
89251   arg1 = (std::vector< Dali::Actor > *)jarg1;
89252   {
89253     try {
89254       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89255     } catch (std::out_of_range& e) {
89256       {
89257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89258       };
89259     } catch (std::exception& e) {
89260       {
89261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89262       };
89263     } catch (Dali::DaliException e) {
89264       {
89265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89266       };
89267     } catch (...) {
89268       {
89269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89270       };
89271     }
89272   }
89273
89274   jresult = (unsigned long)result;
89275   return jresult;
89276 }
89277
89278
89279 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89280   unsigned long jresult ;
89281   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89282   std::vector< Dali::Actor >::size_type result;
89283
89284   arg1 = (std::vector< Dali::Actor > *)jarg1;
89285   {
89286     try {
89287       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89288     } catch (std::out_of_range& e) {
89289       {
89290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89291       };
89292     } catch (std::exception& e) {
89293       {
89294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89295       };
89296     } catch (Dali::DaliException e) {
89297       {
89298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89299       };
89300     } catch (...) {
89301       {
89302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89303       };
89304     }
89305   }
89306
89307   jresult = (unsigned long)result;
89308   return jresult;
89309 }
89310
89311
89312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89313   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89314   std::vector< Dali::Actor >::size_type arg2 ;
89315
89316   arg1 = (std::vector< Dali::Actor > *)jarg1;
89317   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89318   {
89319     try {
89320       (arg1)->reserve(arg2);
89321     } catch (std::out_of_range& e) {
89322       {
89323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89324       };
89325     } catch (std::exception& e) {
89326       {
89327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89328       };
89329     } catch (Dali::DaliException e) {
89330       {
89331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89332       };
89333     } catch (...) {
89334       {
89335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89336       };
89337     }
89338   }
89339
89340 }
89341
89342
89343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89344   void * jresult ;
89345   std::vector< Dali::Actor > *result = 0 ;
89346
89347   {
89348     try {
89349       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89350     } catch (std::out_of_range& e) {
89351       {
89352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89353       };
89354     } catch (std::exception& e) {
89355       {
89356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89357       };
89358     } catch (Dali::DaliException e) {
89359       {
89360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89361       };
89362     } catch (...) {
89363       {
89364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89365       };
89366     }
89367   }
89368
89369   jresult = (void *)result;
89370   return jresult;
89371 }
89372
89373
89374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89375   void * jresult ;
89376   std::vector< Dali::Actor > *arg1 = 0 ;
89377   std::vector< Dali::Actor > *result = 0 ;
89378
89379   arg1 = (std::vector< Dali::Actor > *)jarg1;
89380   if (!arg1) {
89381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89382     return 0;
89383   }
89384   {
89385     try {
89386       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89387     } catch (std::out_of_range& e) {
89388       {
89389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89390       };
89391     } catch (std::exception& e) {
89392       {
89393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89394       };
89395     } catch (Dali::DaliException e) {
89396       {
89397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89398       };
89399     } catch (...) {
89400       {
89401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89402       };
89403     }
89404   }
89405
89406   jresult = (void *)result;
89407   return jresult;
89408 }
89409
89410
89411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89412   void * jresult ;
89413   int arg1 ;
89414   std::vector< Dali::Actor > *result = 0 ;
89415
89416   arg1 = (int)jarg1;
89417   {
89418     try {
89419       try {
89420         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89421       }
89422       catch(std::out_of_range &_e) {
89423         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89424         return 0;
89425       }
89426
89427     } catch (std::out_of_range& e) {
89428       {
89429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89430       };
89431     } catch (std::exception& e) {
89432       {
89433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89434       };
89435     } catch (Dali::DaliException e) {
89436       {
89437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89438       };
89439     } catch (...) {
89440       {
89441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89442       };
89443     }
89444   }
89445
89446   jresult = (void *)result;
89447   return jresult;
89448 }
89449
89450
89451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89452   void * jresult ;
89453   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89454   int arg2 ;
89455   Dali::Actor result;
89456
89457   arg1 = (std::vector< Dali::Actor > *)jarg1;
89458   arg2 = (int)jarg2;
89459   {
89460     try {
89461       try {
89462         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89463       }
89464       catch(std::out_of_range &_e) {
89465         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89466         return 0;
89467       }
89468
89469     } catch (std::out_of_range& e) {
89470       {
89471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89472       };
89473     } catch (std::exception& e) {
89474       {
89475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89476       };
89477     } catch (Dali::DaliException e) {
89478       {
89479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89480       };
89481     } catch (...) {
89482       {
89483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89484       };
89485     }
89486   }
89487
89488   jresult = new Dali::Actor((const Dali::Actor &)result);
89489   return jresult;
89490 }
89491
89492
89493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89494   void * jresult ;
89495   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89496   int arg2 ;
89497   Dali::Actor *result = 0 ;
89498
89499   arg1 = (std::vector< Dali::Actor > *)jarg1;
89500   arg2 = (int)jarg2;
89501   {
89502     try {
89503       try {
89504         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89505       }
89506       catch(std::out_of_range &_e) {
89507         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89508         return 0;
89509       }
89510
89511     } catch (std::out_of_range& e) {
89512       {
89513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89514       };
89515     } catch (std::exception& e) {
89516       {
89517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89518       };
89519     } catch (Dali::DaliException e) {
89520       {
89521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89522       };
89523     } catch (...) {
89524       {
89525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89526       };
89527     }
89528   }
89529
89530   jresult = (void *)result;
89531   return jresult;
89532 }
89533
89534
89535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89536   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89537   int arg2 ;
89538   Dali::Actor *arg3 = 0 ;
89539
89540   arg1 = (std::vector< Dali::Actor > *)jarg1;
89541   arg2 = (int)jarg2;
89542   arg3 = (Dali::Actor *)jarg3;
89543   if (!arg3) {
89544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89545     return ;
89546   }
89547   {
89548     try {
89549       try {
89550         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89551       }
89552       catch(std::out_of_range &_e) {
89553         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89554         return ;
89555       }
89556
89557     } catch (std::out_of_range& e) {
89558       {
89559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89560       };
89561     } catch (std::exception& e) {
89562       {
89563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89564       };
89565     } catch (Dali::DaliException e) {
89566       {
89567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89568       };
89569     } catch (...) {
89570       {
89571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89572       };
89573     }
89574   }
89575
89576 }
89577
89578
89579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89580   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89581   std::vector< Dali::Actor > *arg2 = 0 ;
89582
89583   arg1 = (std::vector< Dali::Actor > *)jarg1;
89584   arg2 = (std::vector< Dali::Actor > *)jarg2;
89585   if (!arg2) {
89586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89587     return ;
89588   }
89589   {
89590     try {
89591       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89592     } catch (std::out_of_range& e) {
89593       {
89594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89595       };
89596     } catch (std::exception& e) {
89597       {
89598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89599       };
89600     } catch (Dali::DaliException e) {
89601       {
89602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89603       };
89604     } catch (...) {
89605       {
89606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89607       };
89608     }
89609   }
89610
89611 }
89612
89613
89614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89615   void * jresult ;
89616   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89617   int arg2 ;
89618   int arg3 ;
89619   std::vector< Dali::Actor > *result = 0 ;
89620
89621   arg1 = (std::vector< Dali::Actor > *)jarg1;
89622   arg2 = (int)jarg2;
89623   arg3 = (int)jarg3;
89624   {
89625     try {
89626       try {
89627         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89628       }
89629       catch(std::out_of_range &_e) {
89630         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89631         return 0;
89632       }
89633       catch(std::invalid_argument &_e) {
89634         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89635         return 0;
89636       }
89637
89638     } catch (std::out_of_range& e) {
89639       {
89640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89641       };
89642     } catch (std::exception& e) {
89643       {
89644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89645       };
89646     } catch (Dali::DaliException e) {
89647       {
89648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89649       };
89650     } catch (...) {
89651       {
89652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89653       };
89654     }
89655   }
89656
89657   jresult = (void *)result;
89658   return jresult;
89659 }
89660
89661
89662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89663   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89664   int arg2 ;
89665   Dali::Actor *arg3 = 0 ;
89666
89667   arg1 = (std::vector< Dali::Actor > *)jarg1;
89668   arg2 = (int)jarg2;
89669   arg3 = (Dali::Actor *)jarg3;
89670   if (!arg3) {
89671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89672     return ;
89673   }
89674   {
89675     try {
89676       try {
89677         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89678       }
89679       catch(std::out_of_range &_e) {
89680         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89681         return ;
89682       }
89683
89684     } catch (std::out_of_range& e) {
89685       {
89686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89687       };
89688     } catch (std::exception& e) {
89689       {
89690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89691       };
89692     } catch (Dali::DaliException e) {
89693       {
89694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89695       };
89696     } catch (...) {
89697       {
89698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89699       };
89700     }
89701   }
89702
89703 }
89704
89705
89706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89707   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89708   int arg2 ;
89709   std::vector< Dali::Actor > *arg3 = 0 ;
89710
89711   arg1 = (std::vector< Dali::Actor > *)jarg1;
89712   arg2 = (int)jarg2;
89713   arg3 = (std::vector< Dali::Actor > *)jarg3;
89714   if (!arg3) {
89715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89716     return ;
89717   }
89718   {
89719     try {
89720       try {
89721         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89722       }
89723       catch(std::out_of_range &_e) {
89724         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89725         return ;
89726       }
89727
89728     } catch (std::out_of_range& e) {
89729       {
89730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89731       };
89732     } catch (std::exception& e) {
89733       {
89734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89735       };
89736     } catch (Dali::DaliException e) {
89737       {
89738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89739       };
89740     } catch (...) {
89741       {
89742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89743       };
89744     }
89745   }
89746
89747 }
89748
89749
89750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89751   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89752   int arg2 ;
89753
89754   arg1 = (std::vector< Dali::Actor > *)jarg1;
89755   arg2 = (int)jarg2;
89756   {
89757     try {
89758       try {
89759         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89760       }
89761       catch(std::out_of_range &_e) {
89762         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89763         return ;
89764       }
89765
89766     } catch (std::out_of_range& e) {
89767       {
89768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89769       };
89770     } catch (std::exception& e) {
89771       {
89772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89773       };
89774     } catch (Dali::DaliException e) {
89775       {
89776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89777       };
89778     } catch (...) {
89779       {
89780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89781       };
89782     }
89783   }
89784
89785 }
89786
89787
89788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89789   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89790   int arg2 ;
89791   int arg3 ;
89792
89793   arg1 = (std::vector< Dali::Actor > *)jarg1;
89794   arg2 = (int)jarg2;
89795   arg3 = (int)jarg3;
89796   {
89797     try {
89798       try {
89799         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89800       }
89801       catch(std::out_of_range &_e) {
89802         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89803         return ;
89804       }
89805       catch(std::invalid_argument &_e) {
89806         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89807         return ;
89808       }
89809
89810     } catch (std::out_of_range& e) {
89811       {
89812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89813       };
89814     } catch (std::exception& e) {
89815       {
89816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89817       };
89818     } catch (Dali::DaliException e) {
89819       {
89820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89821       };
89822     } catch (...) {
89823       {
89824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89825       };
89826     }
89827   }
89828
89829 }
89830
89831
89832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89833   void * jresult ;
89834   Dali::Actor *arg1 = 0 ;
89835   int arg2 ;
89836   std::vector< Dali::Actor > *result = 0 ;
89837
89838   arg1 = (Dali::Actor *)jarg1;
89839   if (!arg1) {
89840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89841     return 0;
89842   }
89843   arg2 = (int)jarg2;
89844   {
89845     try {
89846       try {
89847         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89848       }
89849       catch(std::out_of_range &_e) {
89850         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89851         return 0;
89852       }
89853
89854     } catch (std::out_of_range& e) {
89855       {
89856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89857       };
89858     } catch (std::exception& e) {
89859       {
89860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89861       };
89862     } catch (Dali::DaliException e) {
89863       {
89864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89865       };
89866     } catch (...) {
89867       {
89868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89869       };
89870     }
89871   }
89872
89873   jresult = (void *)result;
89874   return jresult;
89875 }
89876
89877
89878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89879   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89880
89881   arg1 = (std::vector< Dali::Actor > *)jarg1;
89882   {
89883     try {
89884       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89885     } catch (std::out_of_range& e) {
89886       {
89887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89888       };
89889     } catch (std::exception& e) {
89890       {
89891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89892       };
89893     } catch (Dali::DaliException e) {
89894       {
89895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89896       };
89897     } catch (...) {
89898       {
89899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89900       };
89901     }
89902   }
89903
89904 }
89905
89906
89907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89908   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89909   int arg2 ;
89910   int arg3 ;
89911
89912   arg1 = (std::vector< Dali::Actor > *)jarg1;
89913   arg2 = (int)jarg2;
89914   arg3 = (int)jarg3;
89915   {
89916     try {
89917       try {
89918         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89919       }
89920       catch(std::out_of_range &_e) {
89921         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89922         return ;
89923       }
89924       catch(std::invalid_argument &_e) {
89925         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89926         return ;
89927       }
89928
89929     } catch (std::out_of_range& e) {
89930       {
89931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89932       };
89933     } catch (std::exception& e) {
89934       {
89935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89936       };
89937     } catch (Dali::DaliException e) {
89938       {
89939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89940       };
89941     } catch (...) {
89942       {
89943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89944       };
89945     }
89946   }
89947
89948 }
89949
89950
89951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89952   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89953   int arg2 ;
89954   std::vector< Dali::Actor > *arg3 = 0 ;
89955
89956   arg1 = (std::vector< Dali::Actor > *)jarg1;
89957   arg2 = (int)jarg2;
89958   arg3 = (std::vector< Dali::Actor > *)jarg3;
89959   if (!arg3) {
89960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89961     return ;
89962   }
89963   {
89964     try {
89965       try {
89966         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89967       }
89968       catch(std::out_of_range &_e) {
89969         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89970         return ;
89971       }
89972
89973     } catch (std::out_of_range& e) {
89974       {
89975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89976       };
89977     } catch (std::exception& e) {
89978       {
89979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89980       };
89981     } catch (Dali::DaliException e) {
89982       {
89983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89984       };
89985     } catch (...) {
89986       {
89987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89988       };
89989     }
89990   }
89991
89992 }
89993
89994
89995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89996   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89997
89998   arg1 = (std::vector< Dali::Actor > *)jarg1;
89999   {
90000     try {
90001       delete arg1;
90002     } catch (std::out_of_range& e) {
90003       {
90004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90005       };
90006     } catch (std::exception& e) {
90007       {
90008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90009       };
90010     } catch (Dali::DaliException e) {
90011       {
90012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90013       };
90014     } catch (...) {
90015       {
90016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90017       };
90018     }
90019   }
90020
90021 }
90022
90023
90024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
90025   unsigned int jresult ;
90026   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90027   bool result;
90028
90029   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90030   {
90031     try {
90032       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90033     } catch (std::out_of_range& e) {
90034       {
90035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90036       };
90037     } catch (std::exception& e) {
90038       {
90039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90040       };
90041     } catch (Dali::DaliException e) {
90042       {
90043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90044       };
90045     } catch (...) {
90046       {
90047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90048       };
90049     }
90050   }
90051
90052   jresult = result;
90053   return jresult;
90054 }
90055
90056
90057 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
90058   unsigned long jresult ;
90059   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90060   std::size_t result;
90061
90062   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90063   {
90064     try {
90065       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90066     } catch (std::out_of_range& e) {
90067       {
90068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90069       };
90070     } catch (std::exception& e) {
90071       {
90072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90073       };
90074     } catch (Dali::DaliException e) {
90075       {
90076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90077       };
90078     } catch (...) {
90079       {
90080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90081       };
90082     }
90083   }
90084
90085   jresult = (unsigned long)result;
90086   return jresult;
90087 }
90088
90089
90090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
90091   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90092   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90093
90094   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90095   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90096   {
90097     try {
90098       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
90099     } catch (std::out_of_range& e) {
90100       {
90101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90102       };
90103     } catch (std::exception& e) {
90104       {
90105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90106       };
90107     } catch (Dali::DaliException e) {
90108       {
90109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90110       };
90111     } catch (...) {
90112       {
90113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90114       };
90115     }
90116   }
90117
90118 }
90119
90120
90121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
90122   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90123   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90124
90125   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90126   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90127   {
90128     try {
90129       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
90130     } catch (std::out_of_range& e) {
90131       {
90132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90133       };
90134     } catch (std::exception& e) {
90135       {
90136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90137       };
90138     } catch (Dali::DaliException e) {
90139       {
90140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90141       };
90142     } catch (...) {
90143       {
90144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90145       };
90146     }
90147   }
90148
90149 }
90150
90151
90152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
90153   unsigned int jresult ;
90154   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90155   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
90156   bool result;
90157
90158   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90159   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
90160   if (!arg2) {
90161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
90162     return 0;
90163   }
90164   {
90165     try {
90166       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
90167     } catch (std::out_of_range& e) {
90168       {
90169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90170       };
90171     } catch (std::exception& e) {
90172       {
90173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90174       };
90175     } catch (Dali::DaliException e) {
90176       {
90177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90178       };
90179     } catch (...) {
90180       {
90181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90182       };
90183     }
90184   }
90185
90186   jresult = result;
90187   return jresult;
90188 }
90189
90190
90191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90192   void * jresult ;
90193   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90194
90195   {
90196     try {
90197       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90198     } catch (std::out_of_range& e) {
90199       {
90200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90201       };
90202     } catch (std::exception& e) {
90203       {
90204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90205       };
90206     } catch (Dali::DaliException e) {
90207       {
90208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90209       };
90210     } catch (...) {
90211       {
90212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90213       };
90214     }
90215   }
90216
90217   jresult = (void *)result;
90218   return jresult;
90219 }
90220
90221
90222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90223   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90224
90225   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90226   {
90227     try {
90228       delete arg1;
90229     } catch (std::out_of_range& e) {
90230       {
90231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90232       };
90233     } catch (std::exception& e) {
90234       {
90235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90236       };
90237     } catch (Dali::DaliException e) {
90238       {
90239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90240       };
90241     } catch (...) {
90242       {
90243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90244       };
90245     }
90246   }
90247
90248 }
90249
90250
90251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90252   unsigned int jresult ;
90253   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90254   bool result;
90255
90256   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90257   {
90258     try {
90259       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);
90260     } catch (std::out_of_range& e) {
90261       {
90262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90263       };
90264     } catch (std::exception& e) {
90265       {
90266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90267       };
90268     } catch (Dali::DaliException e) {
90269       {
90270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90271       };
90272     } catch (...) {
90273       {
90274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90275       };
90276     }
90277   }
90278
90279   jresult = result;
90280   return jresult;
90281 }
90282
90283
90284 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90285   unsigned long jresult ;
90286   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90287   std::size_t result;
90288
90289   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90290   {
90291     try {
90292       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);
90293     } catch (std::out_of_range& e) {
90294       {
90295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90296       };
90297     } catch (std::exception& e) {
90298       {
90299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90300       };
90301     } catch (Dali::DaliException e) {
90302       {
90303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90304       };
90305     } catch (...) {
90306       {
90307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90308       };
90309     }
90310   }
90311
90312   jresult = (unsigned long)result;
90313   return jresult;
90314 }
90315
90316
90317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90318   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90319   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90320
90321   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90322   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90323   {
90324     try {
90325       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90326     } catch (std::out_of_range& e) {
90327       {
90328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90329       };
90330     } catch (std::exception& e) {
90331       {
90332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90333       };
90334     } catch (Dali::DaliException e) {
90335       {
90336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90337       };
90338     } catch (...) {
90339       {
90340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90341       };
90342     }
90343   }
90344
90345 }
90346
90347
90348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90349   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90350   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90351
90352   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90353   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90354   {
90355     try {
90356       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90357     } catch (std::out_of_range& e) {
90358       {
90359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90360       };
90361     } catch (std::exception& e) {
90362       {
90363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90364       };
90365     } catch (Dali::DaliException e) {
90366       {
90367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90368       };
90369     } catch (...) {
90370       {
90371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90372       };
90373     }
90374   }
90375
90376 }
90377
90378
90379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90380   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90381   Dali::Actor arg2 ;
90382   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90383   Dali::Actor *argp2 ;
90384
90385   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90386   argp2 = (Dali::Actor *)jarg2;
90387   if (!argp2) {
90388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90389     return ;
90390   }
90391   arg2 = *argp2;
90392   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90393   {
90394     try {
90395       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90396     } catch (std::out_of_range& e) {
90397       {
90398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90399       };
90400     } catch (std::exception& e) {
90401       {
90402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90403       };
90404     } catch (Dali::DaliException e) {
90405       {
90406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90407       };
90408     } catch (...) {
90409       {
90410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90411       };
90412     }
90413   }
90414
90415 }
90416
90417
90418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90419   void * jresult ;
90420   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90421
90422   {
90423     try {
90424       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90425     } catch (std::out_of_range& e) {
90426       {
90427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90428       };
90429     } catch (std::exception& e) {
90430       {
90431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90432       };
90433     } catch (Dali::DaliException e) {
90434       {
90435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90436       };
90437     } catch (...) {
90438       {
90439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90440       };
90441     }
90442   }
90443
90444   jresult = (void *)result;
90445   return jresult;
90446 }
90447
90448
90449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90450   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90451
90452   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90453   {
90454     try {
90455       delete arg1;
90456     } catch (std::out_of_range& e) {
90457       {
90458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90459       };
90460     } catch (std::exception& e) {
90461       {
90462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90463       };
90464     } catch (Dali::DaliException e) {
90465       {
90466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90467       };
90468     } catch (...) {
90469       {
90470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90471       };
90472     }
90473   }
90474
90475 }
90476
90477
90478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90479   unsigned int jresult ;
90480   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90481   bool result;
90482
90483   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90484   {
90485     try {
90486       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90487     } catch (std::out_of_range& e) {
90488       {
90489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90490       };
90491     } catch (std::exception& e) {
90492       {
90493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90494       };
90495     } catch (Dali::DaliException e) {
90496       {
90497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90498       };
90499     } catch (...) {
90500       {
90501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90502       };
90503     }
90504   }
90505
90506   jresult = result;
90507   return jresult;
90508 }
90509
90510
90511 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90512   unsigned long jresult ;
90513   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90514   std::size_t result;
90515
90516   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90517   {
90518     try {
90519       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90520     } catch (std::out_of_range& e) {
90521       {
90522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90523       };
90524     } catch (std::exception& e) {
90525       {
90526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90527       };
90528     } catch (Dali::DaliException e) {
90529       {
90530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90531       };
90532     } catch (...) {
90533       {
90534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90535       };
90536     }
90537   }
90538
90539   jresult = (unsigned long)result;
90540   return jresult;
90541 }
90542
90543
90544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90545   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90546   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90547
90548   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90549   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90550   {
90551     try {
90552       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90553     } catch (std::out_of_range& e) {
90554       {
90555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90556       };
90557     } catch (std::exception& e) {
90558       {
90559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90560       };
90561     } catch (Dali::DaliException e) {
90562       {
90563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90564       };
90565     } catch (...) {
90566       {
90567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90568       };
90569     }
90570   }
90571
90572 }
90573
90574
90575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90576   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90577   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90578
90579   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90580   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90581   {
90582     try {
90583       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90584     } catch (std::out_of_range& e) {
90585       {
90586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90587       };
90588     } catch (std::exception& e) {
90589       {
90590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90591       };
90592     } catch (Dali::DaliException e) {
90593       {
90594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90595       };
90596     } catch (...) {
90597       {
90598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90599       };
90600     }
90601   }
90602
90603 }
90604
90605
90606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90607   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90608   Dali::Actor arg2 ;
90609   Dali::Actor arg3 ;
90610   Dali::Actor *argp2 ;
90611   Dali::Actor *argp3 ;
90612
90613   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90614   argp2 = (Dali::Actor *)jarg2;
90615   if (!argp2) {
90616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90617     return ;
90618   }
90619   arg2 = *argp2;
90620   argp3 = (Dali::Actor *)jarg3;
90621   if (!argp3) {
90622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90623     return ;
90624   }
90625   arg3 = *argp3;
90626   {
90627     try {
90628       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90629     } catch (std::out_of_range& e) {
90630       {
90631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90632       };
90633     } catch (std::exception& e) {
90634       {
90635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90636       };
90637     } catch (Dali::DaliException e) {
90638       {
90639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90640       };
90641     } catch (...) {
90642       {
90643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90644       };
90645     }
90646   }
90647
90648 }
90649
90650
90651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90652   void * jresult ;
90653   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90654
90655   {
90656     try {
90657       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90658     } catch (std::out_of_range& e) {
90659       {
90660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90661       };
90662     } catch (std::exception& e) {
90663       {
90664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90665       };
90666     } catch (Dali::DaliException e) {
90667       {
90668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90669       };
90670     } catch (...) {
90671       {
90672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90673       };
90674     }
90675   }
90676
90677   jresult = (void *)result;
90678   return jresult;
90679 }
90680
90681
90682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
90683   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90684
90685   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90686   {
90687     try {
90688       delete arg1;
90689     } catch (std::out_of_range& e) {
90690       {
90691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90692       };
90693     } catch (std::exception& e) {
90694       {
90695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90696       };
90697     } catch (Dali::DaliException e) {
90698       {
90699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90700       };
90701     } catch (...) {
90702       {
90703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90704       };
90705     }
90706   }
90707
90708 }
90709
90710
90711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
90712   unsigned int jresult ;
90713   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90714   bool result;
90715
90716   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90717   {
90718     try {
90719       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90720     } catch (std::out_of_range& e) {
90721       {
90722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90723       };
90724     } catch (std::exception& e) {
90725       {
90726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90727       };
90728     } catch (Dali::DaliException e) {
90729       {
90730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90731       };
90732     } catch (...) {
90733       {
90734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90735       };
90736     }
90737   }
90738
90739   jresult = result;
90740   return jresult;
90741 }
90742
90743
90744 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
90745   unsigned long jresult ;
90746   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90747   std::size_t result;
90748
90749   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90750   {
90751     try {
90752       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90753     } catch (std::out_of_range& e) {
90754       {
90755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90756       };
90757     } catch (std::exception& e) {
90758       {
90759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90760       };
90761     } catch (Dali::DaliException e) {
90762       {
90763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90764       };
90765     } catch (...) {
90766       {
90767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90768       };
90769     }
90770   }
90771
90772   jresult = (unsigned long)result;
90773   return jresult;
90774 }
90775
90776
90777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
90778   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90779   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90780
90781   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90782   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90783   {
90784     try {
90785       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
90786     } catch (std::out_of_range& e) {
90787       {
90788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90789       };
90790     } catch (std::exception& e) {
90791       {
90792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90793       };
90794     } catch (Dali::DaliException e) {
90795       {
90796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90797       };
90798     } catch (...) {
90799       {
90800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90801       };
90802     }
90803   }
90804
90805 }
90806
90807
90808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90809   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90810   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90811
90812   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90813   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90814   {
90815     try {
90816       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90817     } catch (std::out_of_range& e) {
90818       {
90819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90820       };
90821     } catch (std::exception& e) {
90822       {
90823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90824       };
90825     } catch (Dali::DaliException e) {
90826       {
90827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90828       };
90829     } catch (...) {
90830       {
90831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90832       };
90833     }
90834   }
90835
90836 }
90837
90838
90839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
90840   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90841   Dali::Actor arg2 ;
90842   bool arg3 ;
90843   Dali::Actor *argp2 ;
90844
90845   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90846   argp2 = (Dali::Actor *)jarg2;
90847   if (!argp2) {
90848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90849     return ;
90850   }
90851   arg2 = *argp2;
90852   arg3 = jarg3 ? true : false;
90853   {
90854     try {
90855       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
90856     } catch (std::out_of_range& e) {
90857       {
90858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90859       };
90860     } catch (std::exception& e) {
90861       {
90862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90863       };
90864     } catch (Dali::DaliException e) {
90865       {
90866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90867       };
90868     } catch (...) {
90869       {
90870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90871       };
90872     }
90873   }
90874
90875 }
90876
90877
90878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
90879   void * jresult ;
90880   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
90881
90882   {
90883     try {
90884       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90885     } catch (std::out_of_range& e) {
90886       {
90887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90888       };
90889     } catch (std::exception& e) {
90890       {
90891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90892       };
90893     } catch (Dali::DaliException e) {
90894       {
90895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90896       };
90897     } catch (...) {
90898       {
90899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90900       };
90901     }
90902   }
90903
90904   jresult = (void *)result;
90905   return jresult;
90906 }
90907
90908
90909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
90910   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90911
90912   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90913   {
90914     try {
90915       delete arg1;
90916     } catch (std::out_of_range& e) {
90917       {
90918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90919       };
90920     } catch (std::exception& e) {
90921       {
90922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90923       };
90924     } catch (Dali::DaliException e) {
90925       {
90926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90927       };
90928     } catch (...) {
90929       {
90930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90931       };
90932     }
90933   }
90934
90935 }
90936
90937
90938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
90939   unsigned int jresult ;
90940   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90941   bool result;
90942
90943   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90944   {
90945     try {
90946       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);
90947     } catch (std::out_of_range& e) {
90948       {
90949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90950       };
90951     } catch (std::exception& e) {
90952       {
90953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90954       };
90955     } catch (Dali::DaliException e) {
90956       {
90957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90958       };
90959     } catch (...) {
90960       {
90961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90962       };
90963     }
90964   }
90965
90966   jresult = result;
90967   return jresult;
90968 }
90969
90970
90971 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
90972   unsigned long jresult ;
90973   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90974   std::size_t result;
90975
90976   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90977   {
90978     try {
90979       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);
90980     } catch (std::out_of_range& e) {
90981       {
90982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90983       };
90984     } catch (std::exception& e) {
90985       {
90986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90987       };
90988     } catch (Dali::DaliException e) {
90989       {
90990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90991       };
90992     } catch (...) {
90993       {
90994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90995       };
90996     }
90997   }
90998
90999   jresult = (unsigned long)result;
91000   return jresult;
91001 }
91002
91003
91004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
91005   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91006   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91007
91008   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91009   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91010   {
91011     try {
91012       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
91013     } catch (std::out_of_range& e) {
91014       {
91015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91016       };
91017     } catch (std::exception& e) {
91018       {
91019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91020       };
91021     } catch (Dali::DaliException e) {
91022       {
91023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91024       };
91025     } catch (...) {
91026       {
91027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91028       };
91029     }
91030   }
91031
91032 }
91033
91034
91035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91036   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91037   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91038
91039   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91040   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91041   {
91042     try {
91043       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
91044     } catch (std::out_of_range& e) {
91045       {
91046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91047       };
91048     } catch (std::exception& e) {
91049       {
91050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91051       };
91052     } catch (Dali::DaliException e) {
91053       {
91054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91055       };
91056     } catch (...) {
91057       {
91058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91059       };
91060     }
91061   }
91062
91063 }
91064
91065
91066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91067   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91068   Dali::Toolkit::StyleManager arg2 ;
91069   Dali::StyleChange::Type arg3 ;
91070   Dali::Toolkit::StyleManager *argp2 ;
91071
91072   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91073   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
91074   if (!argp2) {
91075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
91076     return ;
91077   }
91078   arg2 = *argp2;
91079   arg3 = (Dali::StyleChange::Type)jarg3;
91080   {
91081     try {
91082       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
91083     } catch (std::out_of_range& e) {
91084       {
91085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91086       };
91087     } catch (std::exception& e) {
91088       {
91089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91090       };
91091     } catch (Dali::DaliException e) {
91092       {
91093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91094       };
91095     } catch (...) {
91096       {
91097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91098       };
91099     }
91100   }
91101
91102 }
91103
91104
91105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
91106   void * jresult ;
91107   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
91108
91109   {
91110     try {
91111       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
91112     } catch (std::out_of_range& e) {
91113       {
91114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91115       };
91116     } catch (std::exception& e) {
91117       {
91118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91119       };
91120     } catch (Dali::DaliException e) {
91121       {
91122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91123       };
91124     } catch (...) {
91125       {
91126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91127       };
91128     }
91129   }
91130
91131   jresult = (void *)result;
91132   return jresult;
91133 }
91134
91135
91136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
91137   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91138
91139   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91140   {
91141     try {
91142       delete arg1;
91143     } catch (std::out_of_range& e) {
91144       {
91145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91146       };
91147     } catch (std::exception& e) {
91148       {
91149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91150       };
91151     } catch (Dali::DaliException e) {
91152       {
91153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91154       };
91155     } catch (...) {
91156       {
91157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91158       };
91159     }
91160   }
91161
91162 }
91163
91164
91165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
91166   unsigned int jresult ;
91167   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91168   bool result;
91169
91170   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91171   {
91172     try {
91173       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91174     } catch (std::out_of_range& e) {
91175       {
91176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91177       };
91178     } catch (std::exception& e) {
91179       {
91180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91181       };
91182     } catch (Dali::DaliException e) {
91183       {
91184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91185       };
91186     } catch (...) {
91187       {
91188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91189       };
91190     }
91191   }
91192
91193   jresult = result;
91194   return jresult;
91195 }
91196
91197
91198 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91199   unsigned long jresult ;
91200   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91201   std::size_t result;
91202
91203   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91204   {
91205     try {
91206       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91207     } catch (std::out_of_range& e) {
91208       {
91209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91210       };
91211     } catch (std::exception& e) {
91212       {
91213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91214       };
91215     } catch (Dali::DaliException e) {
91216       {
91217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91218       };
91219     } catch (...) {
91220       {
91221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91222       };
91223     }
91224   }
91225
91226   jresult = (unsigned long)result;
91227   return jresult;
91228 }
91229
91230
91231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91232   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91233   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91234
91235   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91236   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91237   {
91238     try {
91239       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91240     } catch (std::out_of_range& e) {
91241       {
91242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91243       };
91244     } catch (std::exception& e) {
91245       {
91246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91247       };
91248     } catch (Dali::DaliException e) {
91249       {
91250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91251       };
91252     } catch (...) {
91253       {
91254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91255       };
91256     }
91257   }
91258
91259 }
91260
91261
91262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91263   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91264   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91265
91266   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91267   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91268   {
91269     try {
91270       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91271     } catch (std::out_of_range& e) {
91272       {
91273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91274       };
91275     } catch (std::exception& e) {
91276       {
91277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91278       };
91279     } catch (Dali::DaliException e) {
91280       {
91281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91282       };
91283     } catch (...) {
91284       {
91285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91286       };
91287     }
91288   }
91289
91290 }
91291
91292
91293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91294   unsigned int jresult ;
91295   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91296   Dali::Toolkit::Button arg2 ;
91297   Dali::Toolkit::Button *argp2 ;
91298   bool result;
91299
91300   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91301   argp2 = (Dali::Toolkit::Button *)jarg2;
91302   if (!argp2) {
91303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91304     return 0;
91305   }
91306   arg2 = *argp2;
91307   {
91308     try {
91309       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91310     } catch (std::out_of_range& e) {
91311       {
91312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91313       };
91314     } catch (std::exception& e) {
91315       {
91316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91317       };
91318     } catch (Dali::DaliException e) {
91319       {
91320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91321       };
91322     } catch (...) {
91323       {
91324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91325       };
91326     }
91327   }
91328
91329   jresult = result;
91330   return jresult;
91331 }
91332
91333
91334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91335   void * jresult ;
91336   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91337
91338   {
91339     try {
91340       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91341     } catch (std::out_of_range& e) {
91342       {
91343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91344       };
91345     } catch (std::exception& e) {
91346       {
91347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91348       };
91349     } catch (Dali::DaliException e) {
91350       {
91351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91352       };
91353     } catch (...) {
91354       {
91355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91356       };
91357     }
91358   }
91359
91360   jresult = (void *)result;
91361   return jresult;
91362 }
91363
91364
91365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91366   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91367
91368   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91369   {
91370     try {
91371       delete arg1;
91372     } catch (std::out_of_range& e) {
91373       {
91374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91375       };
91376     } catch (std::exception& e) {
91377       {
91378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91379       };
91380     } catch (Dali::DaliException e) {
91381       {
91382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91383       };
91384     } catch (...) {
91385       {
91386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91387       };
91388     }
91389   }
91390
91391 }
91392
91393
91394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91395   unsigned int jresult ;
91396   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91397   bool result;
91398
91399   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91400   {
91401     try {
91402       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91403     } catch (std::out_of_range& e) {
91404       {
91405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91406       };
91407     } catch (std::exception& e) {
91408       {
91409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91410       };
91411     } catch (Dali::DaliException e) {
91412       {
91413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91414       };
91415     } catch (...) {
91416       {
91417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91418       };
91419     }
91420   }
91421
91422   jresult = result;
91423   return jresult;
91424 }
91425
91426
91427 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91428   unsigned long jresult ;
91429   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91430   std::size_t result;
91431
91432   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91433   {
91434     try {
91435       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91436     } catch (std::out_of_range& e) {
91437       {
91438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91439       };
91440     } catch (std::exception& e) {
91441       {
91442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91443       };
91444     } catch (Dali::DaliException e) {
91445       {
91446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91447       };
91448     } catch (...) {
91449       {
91450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91451       };
91452     }
91453   }
91454
91455   jresult = (unsigned long)result;
91456   return jresult;
91457 }
91458
91459
91460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91461   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91462   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91463
91464   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91465   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91466   {
91467     try {
91468       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91469     } catch (std::out_of_range& e) {
91470       {
91471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91472       };
91473     } catch (std::exception& e) {
91474       {
91475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91476       };
91477     } catch (Dali::DaliException e) {
91478       {
91479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91480       };
91481     } catch (...) {
91482       {
91483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91484       };
91485     }
91486   }
91487
91488 }
91489
91490
91491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91492   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91493   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91494
91495   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91496   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91497   {
91498     try {
91499       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91500     } catch (std::out_of_range& e) {
91501       {
91502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91503       };
91504     } catch (std::exception& e) {
91505       {
91506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91507       };
91508     } catch (Dali::DaliException e) {
91509       {
91510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91511       };
91512     } catch (...) {
91513       {
91514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91515       };
91516     }
91517   }
91518
91519 }
91520
91521
91522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91523   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91524   Dali::Toolkit::GaussianBlurView arg2 ;
91525   Dali::Toolkit::GaussianBlurView *argp2 ;
91526
91527   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91528   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91529   if (!argp2) {
91530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91531     return ;
91532   }
91533   arg2 = *argp2;
91534   {
91535     try {
91536       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91537     } catch (std::out_of_range& e) {
91538       {
91539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91540       };
91541     } catch (std::exception& e) {
91542       {
91543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91544       };
91545     } catch (Dali::DaliException e) {
91546       {
91547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91548       };
91549     } catch (...) {
91550       {
91551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91552       };
91553     }
91554   }
91555
91556 }
91557
91558
91559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91560   void * jresult ;
91561   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91562
91563   {
91564     try {
91565       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91566     } catch (std::out_of_range& e) {
91567       {
91568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91569       };
91570     } catch (std::exception& e) {
91571       {
91572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91573       };
91574     } catch (Dali::DaliException e) {
91575       {
91576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91577       };
91578     } catch (...) {
91579       {
91580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91581       };
91582     }
91583   }
91584
91585   jresult = (void *)result;
91586   return jresult;
91587 }
91588
91589
91590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91591   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91592
91593   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91594   {
91595     try {
91596       delete arg1;
91597     } catch (std::out_of_range& e) {
91598       {
91599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91600       };
91601     } catch (std::exception& e) {
91602       {
91603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91604       };
91605     } catch (Dali::DaliException e) {
91606       {
91607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91608       };
91609     } catch (...) {
91610       {
91611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91612       };
91613     }
91614   }
91615
91616 }
91617
91618
91619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91620   unsigned int jresult ;
91621   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91622   bool result;
91623
91624   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91625   {
91626     try {
91627       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);
91628     } catch (std::out_of_range& e) {
91629       {
91630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91631       };
91632     } catch (std::exception& e) {
91633       {
91634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91635       };
91636     } catch (Dali::DaliException e) {
91637       {
91638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91639       };
91640     } catch (...) {
91641       {
91642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91643       };
91644     }
91645   }
91646
91647   jresult = result;
91648   return jresult;
91649 }
91650
91651
91652 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91653   unsigned long jresult ;
91654   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91655   std::size_t result;
91656
91657   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91658   {
91659     try {
91660       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);
91661     } catch (std::out_of_range& e) {
91662       {
91663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91664       };
91665     } catch (std::exception& e) {
91666       {
91667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91668       };
91669     } catch (Dali::DaliException e) {
91670       {
91671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91672       };
91673     } catch (...) {
91674       {
91675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91676       };
91677     }
91678   }
91679
91680   jresult = (unsigned long)result;
91681   return jresult;
91682 }
91683
91684
91685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
91686   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91687   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91688
91689   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91690   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91691   {
91692     try {
91693       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
91694     } catch (std::out_of_range& e) {
91695       {
91696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91697       };
91698     } catch (std::exception& e) {
91699       {
91700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91701       };
91702     } catch (Dali::DaliException e) {
91703       {
91704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91705       };
91706     } catch (...) {
91707       {
91708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91709       };
91710     }
91711   }
91712
91713 }
91714
91715
91716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
91717   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91718   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91719
91720   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91721   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91722   {
91723     try {
91724       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91725     } catch (std::out_of_range& e) {
91726       {
91727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91728       };
91729     } catch (std::exception& e) {
91730       {
91731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91732       };
91733     } catch (Dali::DaliException e) {
91734       {
91735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91736       };
91737     } catch (...) {
91738       {
91739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91740       };
91741     }
91742   }
91743
91744 }
91745
91746
91747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
91748   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91749   Dali::Toolkit::PageTurnView arg2 ;
91750   unsigned int arg3 ;
91751   bool arg4 ;
91752   Dali::Toolkit::PageTurnView *argp2 ;
91753
91754   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91755   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91756   if (!argp2) {
91757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91758     return ;
91759   }
91760   arg2 = *argp2;
91761   arg3 = (unsigned int)jarg3;
91762   arg4 = jarg4 ? true : false;
91763   {
91764     try {
91765       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91766     } catch (std::out_of_range& e) {
91767       {
91768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91769       };
91770     } catch (std::exception& e) {
91771       {
91772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91773       };
91774     } catch (Dali::DaliException e) {
91775       {
91776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91777       };
91778     } catch (...) {
91779       {
91780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91781       };
91782     }
91783   }
91784
91785 }
91786
91787
91788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
91789   void * jresult ;
91790   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
91791
91792   {
91793     try {
91794       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
91795     } catch (std::out_of_range& e) {
91796       {
91797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91798       };
91799     } catch (std::exception& e) {
91800       {
91801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91802       };
91803     } catch (Dali::DaliException e) {
91804       {
91805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91806       };
91807     } catch (...) {
91808       {
91809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91810       };
91811     }
91812   }
91813
91814   jresult = (void *)result;
91815   return jresult;
91816 }
91817
91818
91819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
91820   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91821
91822   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91823   {
91824     try {
91825       delete arg1;
91826     } catch (std::out_of_range& e) {
91827       {
91828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91829       };
91830     } catch (std::exception& e) {
91831       {
91832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91833       };
91834     } catch (Dali::DaliException e) {
91835       {
91836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91837       };
91838     } catch (...) {
91839       {
91840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91841       };
91842     }
91843   }
91844
91845 }
91846
91847
91848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
91849   unsigned int jresult ;
91850   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91851   bool result;
91852
91853   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91854   {
91855     try {
91856       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91857     } catch (std::out_of_range& e) {
91858       {
91859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91860       };
91861     } catch (std::exception& e) {
91862       {
91863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91864       };
91865     } catch (Dali::DaliException e) {
91866       {
91867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91868       };
91869     } catch (...) {
91870       {
91871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91872       };
91873     }
91874   }
91875
91876   jresult = result;
91877   return jresult;
91878 }
91879
91880
91881 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
91882   unsigned long jresult ;
91883   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91884   std::size_t result;
91885
91886   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91887   {
91888     try {
91889       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91890     } catch (std::out_of_range& e) {
91891       {
91892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91893       };
91894     } catch (std::exception& e) {
91895       {
91896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91897       };
91898     } catch (Dali::DaliException e) {
91899       {
91900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91901       };
91902     } catch (...) {
91903       {
91904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91905       };
91906     }
91907   }
91908
91909   jresult = (unsigned long)result;
91910   return jresult;
91911 }
91912
91913
91914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
91915   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91916   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91917
91918   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91919   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91920   {
91921     try {
91922       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
91923     } catch (std::out_of_range& e) {
91924       {
91925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91926       };
91927     } catch (std::exception& e) {
91928       {
91929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91930       };
91931     } catch (Dali::DaliException e) {
91932       {
91933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91934       };
91935     } catch (...) {
91936       {
91937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91938       };
91939     }
91940   }
91941
91942 }
91943
91944
91945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
91946   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91947   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91948
91949   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91950   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91951   {
91952     try {
91953       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
91954     } catch (std::out_of_range& e) {
91955       {
91956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91957       };
91958     } catch (std::exception& e) {
91959       {
91960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91961       };
91962     } catch (Dali::DaliException e) {
91963       {
91964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91965       };
91966     } catch (...) {
91967       {
91968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91969       };
91970     }
91971   }
91972
91973 }
91974
91975
91976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
91977   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91978   Dali::Toolkit::PageTurnView arg2 ;
91979   Dali::Toolkit::PageTurnView *argp2 ;
91980
91981   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91982   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91983   if (!argp2) {
91984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91985     return ;
91986   }
91987   arg2 = *argp2;
91988   {
91989     try {
91990       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
91991     } catch (std::out_of_range& e) {
91992       {
91993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91994       };
91995     } catch (std::exception& e) {
91996       {
91997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91998       };
91999     } catch (Dali::DaliException e) {
92000       {
92001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92002       };
92003     } catch (...) {
92004       {
92005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92006       };
92007     }
92008   }
92009
92010 }
92011
92012
92013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
92014   void * jresult ;
92015   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
92016
92017   {
92018     try {
92019       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
92020     } catch (std::out_of_range& e) {
92021       {
92022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92023       };
92024     } catch (std::exception& e) {
92025       {
92026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92027       };
92028     } catch (Dali::DaliException e) {
92029       {
92030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92031       };
92032     } catch (...) {
92033       {
92034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92035       };
92036     }
92037   }
92038
92039   jresult = (void *)result;
92040   return jresult;
92041 }
92042
92043
92044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
92045   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92046
92047   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92048   {
92049     try {
92050       delete arg1;
92051     } catch (std::out_of_range& e) {
92052       {
92053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92054       };
92055     } catch (std::exception& e) {
92056       {
92057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92058       };
92059     } catch (Dali::DaliException e) {
92060       {
92061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92062       };
92063     } catch (...) {
92064       {
92065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92066       };
92067     }
92068   }
92069
92070 }
92071
92072
92073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
92074   unsigned int jresult ;
92075   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92076   bool result;
92077
92078   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92079   {
92080     try {
92081       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);
92082     } catch (std::out_of_range& e) {
92083       {
92084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92085       };
92086     } catch (std::exception& e) {
92087       {
92088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92089       };
92090     } catch (Dali::DaliException e) {
92091       {
92092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92093       };
92094     } catch (...) {
92095       {
92096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92097       };
92098     }
92099   }
92100
92101   jresult = result;
92102   return jresult;
92103 }
92104
92105
92106 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
92107   unsigned long jresult ;
92108   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92109   std::size_t result;
92110
92111   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92112   {
92113     try {
92114       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);
92115     } catch (std::out_of_range& e) {
92116       {
92117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92118       };
92119     } catch (std::exception& e) {
92120       {
92121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92122       };
92123     } catch (Dali::DaliException e) {
92124       {
92125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92126       };
92127     } catch (...) {
92128       {
92129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92130       };
92131     }
92132   }
92133
92134   jresult = (unsigned long)result;
92135   return jresult;
92136 }
92137
92138
92139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92140   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92141   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92142
92143   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92144   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92145   {
92146     try {
92147       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
92148     } catch (std::out_of_range& e) {
92149       {
92150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92151       };
92152     } catch (std::exception& e) {
92153       {
92154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92155       };
92156     } catch (Dali::DaliException e) {
92157       {
92158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92159       };
92160     } catch (...) {
92161       {
92162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92163       };
92164     }
92165   }
92166
92167 }
92168
92169
92170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92171   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92172   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92173
92174   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92175   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92176   {
92177     try {
92178       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92179     } catch (std::out_of_range& e) {
92180       {
92181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92182       };
92183     } catch (std::exception& e) {
92184       {
92185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92186       };
92187     } catch (Dali::DaliException e) {
92188       {
92189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92190       };
92191     } catch (...) {
92192       {
92193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92194       };
92195     }
92196   }
92197
92198 }
92199
92200
92201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92202   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92203   Dali::Toolkit::ProgressBar arg2 ;
92204   float arg3 ;
92205   float arg4 ;
92206   Dali::Toolkit::ProgressBar *argp2 ;
92207
92208   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92209   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92210   if (!argp2) {
92211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92212     return ;
92213   }
92214   arg2 = *argp2;
92215   arg3 = (float)jarg3;
92216   arg4 = (float)jarg4;
92217   {
92218     try {
92219       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92220     } catch (std::out_of_range& e) {
92221       {
92222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92223       };
92224     } catch (std::exception& e) {
92225       {
92226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92227       };
92228     } catch (Dali::DaliException e) {
92229       {
92230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92231       };
92232     } catch (...) {
92233       {
92234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92235       };
92236     }
92237   }
92238
92239 }
92240
92241
92242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92243   void * jresult ;
92244   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92245
92246   {
92247     try {
92248       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92249     } catch (std::out_of_range& e) {
92250       {
92251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92252       };
92253     } catch (std::exception& e) {
92254       {
92255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92256       };
92257     } catch (Dali::DaliException e) {
92258       {
92259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92260       };
92261     } catch (...) {
92262       {
92263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92264       };
92265     }
92266   }
92267
92268   jresult = (void *)result;
92269   return jresult;
92270 }
92271
92272
92273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92274   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92275
92276   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92277   {
92278     try {
92279       delete arg1;
92280     } catch (std::out_of_range& e) {
92281       {
92282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92283       };
92284     } catch (std::exception& e) {
92285       {
92286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92287       };
92288     } catch (Dali::DaliException e) {
92289       {
92290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92291       };
92292     } catch (...) {
92293       {
92294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92295       };
92296     }
92297   }
92298
92299 }
92300
92301
92302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92303   unsigned int jresult ;
92304   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92305   bool result;
92306
92307   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92308   {
92309     try {
92310       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);
92311     } catch (std::out_of_range& e) {
92312       {
92313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92314       };
92315     } catch (std::exception& e) {
92316       {
92317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92318       };
92319     } catch (Dali::DaliException e) {
92320       {
92321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92322       };
92323     } catch (...) {
92324       {
92325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92326       };
92327     }
92328   }
92329
92330   jresult = result;
92331   return jresult;
92332 }
92333
92334
92335 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92336   unsigned long jresult ;
92337   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92338   std::size_t result;
92339
92340   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92341   {
92342     try {
92343       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);
92344     } catch (std::out_of_range& e) {
92345       {
92346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92347       };
92348     } catch (std::exception& e) {
92349       {
92350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92351       };
92352     } catch (Dali::DaliException e) {
92353       {
92354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92355       };
92356     } catch (...) {
92357       {
92358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92359       };
92360     }
92361   }
92362
92363   jresult = (unsigned long)result;
92364   return jresult;
92365 }
92366
92367
92368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92369   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92370   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92371
92372   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92373   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92374   {
92375     try {
92376       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92377     } catch (std::out_of_range& e) {
92378       {
92379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92380       };
92381     } catch (std::exception& e) {
92382       {
92383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92384       };
92385     } catch (Dali::DaliException e) {
92386       {
92387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92388       };
92389     } catch (...) {
92390       {
92391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92392       };
92393     }
92394   }
92395
92396 }
92397
92398
92399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92400   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92401   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92402
92403   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92404   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92405   {
92406     try {
92407       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92408     } catch (std::out_of_range& e) {
92409       {
92410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92411       };
92412     } catch (std::exception& e) {
92413       {
92414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92415       };
92416     } catch (Dali::DaliException e) {
92417       {
92418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92419       };
92420     } catch (...) {
92421       {
92422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92423       };
92424     }
92425   }
92426
92427 }
92428
92429
92430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92431   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92432   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92433
92434   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92435   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92436   if (!arg2) {
92437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92438     return ;
92439   }
92440   {
92441     try {
92442       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92443     } catch (std::out_of_range& e) {
92444       {
92445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92446       };
92447     } catch (std::exception& e) {
92448       {
92449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92450       };
92451     } catch (Dali::DaliException e) {
92452       {
92453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92454       };
92455     } catch (...) {
92456       {
92457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92458       };
92459     }
92460   }
92461
92462 }
92463
92464
92465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92466   void * jresult ;
92467   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92468
92469   {
92470     try {
92471       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92472     } catch (std::out_of_range& e) {
92473       {
92474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92475       };
92476     } catch (std::exception& e) {
92477       {
92478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92479       };
92480     } catch (Dali::DaliException e) {
92481       {
92482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92483       };
92484     } catch (...) {
92485       {
92486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92487       };
92488     }
92489   }
92490
92491   jresult = (void *)result;
92492   return jresult;
92493 }
92494
92495
92496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92497   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92498
92499   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92500   {
92501     try {
92502       delete arg1;
92503     } catch (std::out_of_range& e) {
92504       {
92505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92506       };
92507     } catch (std::exception& e) {
92508       {
92509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92510       };
92511     } catch (Dali::DaliException e) {
92512       {
92513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92514       };
92515     } catch (...) {
92516       {
92517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92518       };
92519     }
92520   }
92521
92522 }
92523
92524
92525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92526   unsigned int jresult ;
92527   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92528   bool result;
92529
92530   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92531   {
92532     try {
92533       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92534     } catch (std::out_of_range& e) {
92535       {
92536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92537       };
92538     } catch (std::exception& e) {
92539       {
92540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92541       };
92542     } catch (Dali::DaliException e) {
92543       {
92544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92545       };
92546     } catch (...) {
92547       {
92548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92549       };
92550     }
92551   }
92552
92553   jresult = result;
92554   return jresult;
92555 }
92556
92557
92558 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92559   unsigned long jresult ;
92560   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92561   std::size_t result;
92562
92563   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92564   {
92565     try {
92566       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92567     } catch (std::out_of_range& e) {
92568       {
92569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92570       };
92571     } catch (std::exception& e) {
92572       {
92573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92574       };
92575     } catch (Dali::DaliException e) {
92576       {
92577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92578       };
92579     } catch (...) {
92580       {
92581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92582       };
92583     }
92584   }
92585
92586   jresult = (unsigned long)result;
92587   return jresult;
92588 }
92589
92590
92591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92592   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92593   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92594
92595   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92596   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92597   {
92598     try {
92599       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92600     } catch (std::out_of_range& e) {
92601       {
92602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92603       };
92604     } catch (std::exception& e) {
92605       {
92606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92607       };
92608     } catch (Dali::DaliException e) {
92609       {
92610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92611       };
92612     } catch (...) {
92613       {
92614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92615       };
92616     }
92617   }
92618
92619 }
92620
92621
92622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92623   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92624   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92625
92626   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92627   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92628   {
92629     try {
92630       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92631     } catch (std::out_of_range& e) {
92632       {
92633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92634       };
92635     } catch (std::exception& e) {
92636       {
92637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92638       };
92639     } catch (Dali::DaliException e) {
92640       {
92641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92642       };
92643     } catch (...) {
92644       {
92645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92646       };
92647     }
92648   }
92649
92650 }
92651
92652
92653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92654   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92655   Dali::Vector2 *arg2 = 0 ;
92656
92657   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92658   arg2 = (Dali::Vector2 *)jarg2;
92659   if (!arg2) {
92660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92661     return ;
92662   }
92663   {
92664     try {
92665       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92666     } catch (std::out_of_range& e) {
92667       {
92668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92669       };
92670     } catch (std::exception& e) {
92671       {
92672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92673       };
92674     } catch (Dali::DaliException e) {
92675       {
92676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92677       };
92678     } catch (...) {
92679       {
92680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92681       };
92682     }
92683   }
92684
92685 }
92686
92687
92688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
92689   void * jresult ;
92690   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
92691
92692   {
92693     try {
92694       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
92695     } catch (std::out_of_range& e) {
92696       {
92697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92698       };
92699     } catch (std::exception& e) {
92700       {
92701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92702       };
92703     } catch (Dali::DaliException e) {
92704       {
92705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92706       };
92707     } catch (...) {
92708       {
92709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92710       };
92711     }
92712   }
92713
92714   jresult = (void *)result;
92715   return jresult;
92716 }
92717
92718
92719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
92720   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92721
92722   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92723   {
92724     try {
92725       delete arg1;
92726     } catch (std::out_of_range& e) {
92727       {
92728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92729       };
92730     } catch (std::exception& e) {
92731       {
92732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92733       };
92734     } catch (Dali::DaliException e) {
92735       {
92736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92737       };
92738     } catch (...) {
92739       {
92740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92741       };
92742     }
92743   }
92744
92745 }
92746
92747
92748
92749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
92750   unsigned int jresult ;
92751   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92752   bool result;
92753
92754   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92755   {
92756     try {
92757       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);
92758     } catch (std::out_of_range& e) {
92759       {
92760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92761       };
92762     } catch (std::exception& e) {
92763       {
92764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92765       };
92766     } catch (Dali::DaliException e) {
92767       {
92768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92769       };
92770     } catch (...) {
92771       {
92772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92773       };
92774     }
92775   }
92776
92777   jresult = result;
92778   return jresult;
92779 }
92780
92781
92782 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92783   unsigned long jresult ;
92784   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92785   std::size_t result;
92786
92787   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92788   {
92789     try {
92790       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);
92791     } catch (std::out_of_range& e) {
92792       {
92793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92794       };
92795     } catch (std::exception& e) {
92796       {
92797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92798       };
92799     } catch (Dali::DaliException e) {
92800       {
92801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92802       };
92803     } catch (...) {
92804       {
92805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92806       };
92807     }
92808   }
92809
92810   jresult = (unsigned long)result;
92811   return jresult;
92812 }
92813
92814
92815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92816   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92817   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92818
92819   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92820   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92821   {
92822     try {
92823       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92824     } catch (std::out_of_range& e) {
92825       {
92826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92827       };
92828     } catch (std::exception& e) {
92829       {
92830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92831       };
92832     } catch (Dali::DaliException e) {
92833       {
92834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92835       };
92836     } catch (...) {
92837       {
92838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92839       };
92840     }
92841   }
92842
92843 }
92844
92845
92846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92847   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92848   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92849
92850   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92851   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92852   {
92853     try {
92854       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92855     } catch (std::out_of_range& e) {
92856       {
92857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92858       };
92859     } catch (std::exception& e) {
92860       {
92861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92862       };
92863     } catch (Dali::DaliException e) {
92864       {
92865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92866       };
92867     } catch (...) {
92868       {
92869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92870       };
92871     }
92872   }
92873
92874 }
92875
92876
92877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92878   unsigned int jresult ;
92879   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92880   Dali::Toolkit::Control arg2 ;
92881   Dali::KeyEvent *arg3 = 0 ;
92882   Dali::Toolkit::Control *argp2 ;
92883   bool result;
92884
92885   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92886   argp2 = (Dali::Toolkit::Control *)jarg2;
92887   if (!argp2) {
92888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92889     return 0;
92890   }
92891   arg2 = *argp2;
92892   arg3 = (Dali::KeyEvent *)jarg3;
92893   if (!arg3) {
92894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92895     return 0;
92896   }
92897   {
92898     try {
92899       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);
92900     } catch (std::out_of_range& e) {
92901       {
92902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92903       };
92904     } catch (std::exception& e) {
92905       {
92906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92907       };
92908     } catch (Dali::DaliException e) {
92909       {
92910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92911       };
92912     } catch (...) {
92913       {
92914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92915       };
92916     }
92917   }
92918
92919   jresult = result;
92920   return jresult;
92921 }
92922
92923
92924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92925   void * jresult ;
92926   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92927
92928   {
92929     try {
92930       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92931     } catch (std::out_of_range& e) {
92932       {
92933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92934       };
92935     } catch (std::exception& e) {
92936       {
92937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92938       };
92939     } catch (Dali::DaliException e) {
92940       {
92941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92942       };
92943     } catch (...) {
92944       {
92945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92946       };
92947     }
92948   }
92949
92950   jresult = (void *)result;
92951   return jresult;
92952 }
92953
92954
92955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92956   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92957
92958   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92959   {
92960     try {
92961       delete arg1;
92962     } catch (std::out_of_range& e) {
92963       {
92964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92965       };
92966     } catch (std::exception& e) {
92967       {
92968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92969       };
92970     } catch (Dali::DaliException e) {
92971       {
92972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92973       };
92974     } catch (...) {
92975       {
92976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92977       };
92978     }
92979   }
92980
92981 }
92982
92983
92984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92985   unsigned int jresult ;
92986   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92987   bool result;
92988
92989   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92990   {
92991     try {
92992       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92993     } catch (std::out_of_range& e) {
92994       {
92995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92996       };
92997     } catch (std::exception& e) {
92998       {
92999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93000       };
93001     } catch (Dali::DaliException e) {
93002       {
93003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93004       };
93005     } catch (...) {
93006       {
93007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93008       };
93009     }
93010   }
93011
93012   jresult = result;
93013   return jresult;
93014 }
93015
93016
93017 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
93018   unsigned long jresult ;
93019   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93020   std::size_t result;
93021
93022   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93023   {
93024     try {
93025       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93026     } catch (std::out_of_range& e) {
93027       {
93028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93029       };
93030     } catch (std::exception& e) {
93031       {
93032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93033       };
93034     } catch (Dali::DaliException e) {
93035       {
93036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93037       };
93038     } catch (...) {
93039       {
93040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93041       };
93042     }
93043   }
93044
93045   jresult = (unsigned long)result;
93046   return jresult;
93047 }
93048
93049
93050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
93051   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93052   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93053
93054   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93055   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93056   {
93057     try {
93058       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93059     } catch (std::out_of_range& e) {
93060       {
93061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93062       };
93063     } catch (std::exception& e) {
93064       {
93065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93066       };
93067     } catch (Dali::DaliException e) {
93068       {
93069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93070       };
93071     } catch (...) {
93072       {
93073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93074       };
93075     }
93076   }
93077
93078 }
93079
93080
93081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
93082   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93083   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93084
93085   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93086   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93087   {
93088     try {
93089       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93090     } catch (std::out_of_range& e) {
93091       {
93092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93093       };
93094     } catch (std::exception& e) {
93095       {
93096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93097       };
93098     } catch (Dali::DaliException e) {
93099       {
93100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93101       };
93102     } catch (...) {
93103       {
93104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93105       };
93106     }
93107   }
93108
93109 }
93110
93111
93112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
93113   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93114   Dali::Toolkit::Control arg2 ;
93115   Dali::Toolkit::Control *argp2 ;
93116
93117   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93118   argp2 = (Dali::Toolkit::Control *)jarg2;
93119   if (!argp2) {
93120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93121     return ;
93122   }
93123   arg2 = *argp2;
93124   {
93125     try {
93126       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93127     } catch (std::out_of_range& e) {
93128       {
93129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93130       };
93131     } catch (std::exception& e) {
93132       {
93133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93134       };
93135     } catch (Dali::DaliException e) {
93136       {
93137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93138       };
93139     } catch (...) {
93140       {
93141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93142       };
93143     }
93144   }
93145
93146 }
93147
93148
93149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
93150   void * jresult ;
93151   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93152
93153   {
93154     try {
93155       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93156     } catch (std::out_of_range& e) {
93157       {
93158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93159       };
93160     } catch (std::exception& e) {
93161       {
93162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93163       };
93164     } catch (Dali::DaliException e) {
93165       {
93166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93167       };
93168     } catch (...) {
93169       {
93170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93171       };
93172     }
93173   }
93174
93175   jresult = (void *)result;
93176   return jresult;
93177 }
93178
93179
93180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93181   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93182
93183   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93184   {
93185     try {
93186       delete arg1;
93187     } catch (std::out_of_range& e) {
93188       {
93189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93190       };
93191     } catch (std::exception& e) {
93192       {
93193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93194       };
93195     } catch (Dali::DaliException e) {
93196       {
93197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93198       };
93199     } catch (...) {
93200       {
93201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93202       };
93203     }
93204   }
93205
93206 }
93207
93208
93209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93210   unsigned int jresult ;
93211   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93212   bool result;
93213
93214   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93215   {
93216     try {
93217       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93218     } catch (std::out_of_range& e) {
93219       {
93220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93221       };
93222     } catch (std::exception& e) {
93223       {
93224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93225       };
93226     } catch (Dali::DaliException e) {
93227       {
93228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93229       };
93230     } catch (...) {
93231       {
93232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93233       };
93234     }
93235   }
93236
93237   jresult = result;
93238   return jresult;
93239 }
93240
93241
93242 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93243   unsigned long jresult ;
93244   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93245   std::size_t result;
93246
93247   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93248   {
93249     try {
93250       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93251     } catch (std::out_of_range& e) {
93252       {
93253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93254       };
93255     } catch (std::exception& e) {
93256       {
93257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93258       };
93259     } catch (Dali::DaliException e) {
93260       {
93261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93262       };
93263     } catch (...) {
93264       {
93265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93266       };
93267     }
93268   }
93269
93270   jresult = (unsigned long)result;
93271   return jresult;
93272 }
93273
93274
93275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93276   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93277   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93278
93279   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93280   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93281   {
93282     try {
93283       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93284     } catch (std::out_of_range& e) {
93285       {
93286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93287       };
93288     } catch (std::exception& e) {
93289       {
93290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93291       };
93292     } catch (Dali::DaliException e) {
93293       {
93294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93295       };
93296     } catch (...) {
93297       {
93298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93299       };
93300     }
93301   }
93302
93303 }
93304
93305
93306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93307   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93308   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93309
93310   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93311   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93312   {
93313     try {
93314       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93315     } catch (std::out_of_range& e) {
93316       {
93317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93318       };
93319     } catch (std::exception& e) {
93320       {
93321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93322       };
93323     } catch (Dali::DaliException e) {
93324       {
93325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93326       };
93327     } catch (...) {
93328       {
93329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93330       };
93331     }
93332   }
93333
93334 }
93335
93336
93337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93338   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93339   Dali::Toolkit::VideoView *arg2 = 0 ;
93340
93341   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93342   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93343   if (!arg2) {
93344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93345     return ;
93346   }
93347   {
93348     try {
93349       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93350     } catch (std::out_of_range& e) {
93351       {
93352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93353       };
93354     } catch (std::exception& e) {
93355       {
93356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93357       };
93358     } catch (Dali::DaliException e) {
93359       {
93360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93361       };
93362     } catch (...) {
93363       {
93364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93365       };
93366     }
93367   }
93368
93369 }
93370
93371
93372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93373   void * jresult ;
93374   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93375
93376   {
93377     try {
93378       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93379     } catch (std::out_of_range& e) {
93380       {
93381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93382       };
93383     } catch (std::exception& e) {
93384       {
93385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93386       };
93387     } catch (Dali::DaliException e) {
93388       {
93389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93390       };
93391     } catch (...) {
93392       {
93393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93394       };
93395     }
93396   }
93397
93398   jresult = (void *)result;
93399   return jresult;
93400 }
93401
93402
93403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93404   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93405
93406   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93407   {
93408     try {
93409       delete arg1;
93410     } catch (std::out_of_range& e) {
93411       {
93412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93413       };
93414     } catch (std::exception& e) {
93415       {
93416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93417       };
93418     } catch (Dali::DaliException e) {
93419       {
93420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93421       };
93422     } catch (...) {
93423       {
93424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93425       };
93426     }
93427   }
93428
93429 }
93430
93431
93432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93433   unsigned int jresult ;
93434   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93435   bool result;
93436
93437   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93438   {
93439     try {
93440       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93441     } catch (std::out_of_range& e) {
93442       {
93443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93444       };
93445     } catch (std::exception& e) {
93446       {
93447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93448       };
93449     } catch (Dali::DaliException e) {
93450       {
93451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93452       };
93453     } catch (...) {
93454       {
93455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93456       };
93457     }
93458   }
93459
93460   jresult = result;
93461   return jresult;
93462 }
93463
93464
93465 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93466   unsigned long jresult ;
93467   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93468   std::size_t result;
93469
93470   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93471   {
93472     try {
93473       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93474     } catch (std::out_of_range& e) {
93475       {
93476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93477       };
93478     } catch (std::exception& e) {
93479       {
93480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93481       };
93482     } catch (Dali::DaliException e) {
93483       {
93484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93485       };
93486     } catch (...) {
93487       {
93488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93489       };
93490     }
93491   }
93492
93493   jresult = (unsigned long)result;
93494   return jresult;
93495 }
93496
93497
93498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93499   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93500   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93501
93502   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93503   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93504   {
93505     try {
93506       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93507     } catch (std::out_of_range& e) {
93508       {
93509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93510       };
93511     } catch (std::exception& e) {
93512       {
93513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93514       };
93515     } catch (Dali::DaliException e) {
93516       {
93517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93518       };
93519     } catch (...) {
93520       {
93521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93522       };
93523     }
93524   }
93525
93526 }
93527
93528
93529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93530   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93531   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93532
93533   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93534   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93535   {
93536     try {
93537       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93538     } catch (std::out_of_range& e) {
93539       {
93540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93541       };
93542     } catch (std::exception& e) {
93543       {
93544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93545       };
93546     } catch (Dali::DaliException e) {
93547       {
93548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93549       };
93550     } catch (...) {
93551       {
93552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93553       };
93554     }
93555   }
93556
93557 }
93558
93559
93560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93561   unsigned int jresult ;
93562   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93563   Dali::Toolkit::Slider arg2 ;
93564   float arg3 ;
93565   Dali::Toolkit::Slider *argp2 ;
93566   bool result;
93567
93568   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93569   argp2 = (Dali::Toolkit::Slider *)jarg2;
93570   if (!argp2) {
93571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93572     return 0;
93573   }
93574   arg2 = *argp2;
93575   arg3 = (float)jarg3;
93576   {
93577     try {
93578       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93579     } catch (std::out_of_range& e) {
93580       {
93581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93582       };
93583     } catch (std::exception& e) {
93584       {
93585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93586       };
93587     } catch (Dali::DaliException e) {
93588       {
93589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93590       };
93591     } catch (...) {
93592       {
93593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93594       };
93595     }
93596   }
93597
93598   jresult = result;
93599   return jresult;
93600 }
93601
93602
93603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93604   void * jresult ;
93605   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93606
93607   {
93608     try {
93609       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93610     } catch (std::out_of_range& e) {
93611       {
93612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93613       };
93614     } catch (std::exception& e) {
93615       {
93616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93617       };
93618     } catch (Dali::DaliException e) {
93619       {
93620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93621       };
93622     } catch (...) {
93623       {
93624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93625       };
93626     }
93627   }
93628
93629   jresult = (void *)result;
93630   return jresult;
93631 }
93632
93633
93634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93635   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93636
93637   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93638   {
93639     try {
93640       delete arg1;
93641     } catch (std::out_of_range& e) {
93642       {
93643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93644       };
93645     } catch (std::exception& e) {
93646       {
93647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93648       };
93649     } catch (Dali::DaliException e) {
93650       {
93651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93652       };
93653     } catch (...) {
93654       {
93655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93656       };
93657     }
93658   }
93659
93660 }
93661
93662
93663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93664   unsigned int jresult ;
93665   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93666   bool result;
93667
93668   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93669   {
93670     try {
93671       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93672     } catch (std::out_of_range& e) {
93673       {
93674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93675       };
93676     } catch (std::exception& e) {
93677       {
93678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93679       };
93680     } catch (Dali::DaliException e) {
93681       {
93682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93683       };
93684     } catch (...) {
93685       {
93686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93687       };
93688     }
93689   }
93690
93691   jresult = result;
93692   return jresult;
93693 }
93694
93695
93696 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
93697   unsigned long jresult ;
93698   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93699   std::size_t result;
93700
93701   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93702   {
93703     try {
93704       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93705     } catch (std::out_of_range& e) {
93706       {
93707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93708       };
93709     } catch (std::exception& e) {
93710       {
93711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93712       };
93713     } catch (Dali::DaliException e) {
93714       {
93715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93716       };
93717     } catch (...) {
93718       {
93719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93720       };
93721     }
93722   }
93723
93724   jresult = (unsigned long)result;
93725   return jresult;
93726 }
93727
93728
93729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
93730   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93731   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93732
93733   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93734   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93735   {
93736     try {
93737       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
93738     } catch (std::out_of_range& e) {
93739       {
93740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93741       };
93742     } catch (std::exception& e) {
93743       {
93744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93745       };
93746     } catch (Dali::DaliException e) {
93747       {
93748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93749       };
93750     } catch (...) {
93751       {
93752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93753       };
93754     }
93755   }
93756
93757 }
93758
93759
93760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
93761   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93762   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93763
93764   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93765   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93766   {
93767     try {
93768       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
93769     } catch (std::out_of_range& e) {
93770       {
93771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93772       };
93773     } catch (std::exception& e) {
93774       {
93775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93776       };
93777     } catch (Dali::DaliException e) {
93778       {
93779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93780       };
93781     } catch (...) {
93782       {
93783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93784       };
93785     }
93786   }
93787
93788 }
93789
93790
93791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93792   unsigned int jresult ;
93793   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93794   Dali::Toolkit::Slider arg2 ;
93795   int arg3 ;
93796   Dali::Toolkit::Slider *argp2 ;
93797   bool result;
93798
93799   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93800   argp2 = (Dali::Toolkit::Slider *)jarg2;
93801   if (!argp2) {
93802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93803     return 0;
93804   }
93805   arg2 = *argp2;
93806   arg3 = (int)jarg3;
93807   {
93808     try {
93809       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
93810     } catch (std::out_of_range& e) {
93811       {
93812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93813       };
93814     } catch (std::exception& e) {
93815       {
93816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93817       };
93818     } catch (Dali::DaliException e) {
93819       {
93820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93821       };
93822     } catch (...) {
93823       {
93824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93825       };
93826     }
93827   }
93828
93829   jresult = result;
93830   return jresult;
93831 }
93832
93833
93834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
93835   void * jresult ;
93836   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
93837
93838   {
93839     try {
93840       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
93841     } catch (std::out_of_range& e) {
93842       {
93843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93844       };
93845     } catch (std::exception& e) {
93846       {
93847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93848       };
93849     } catch (Dali::DaliException e) {
93850       {
93851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93852       };
93853     } catch (...) {
93854       {
93855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93856       };
93857     }
93858   }
93859
93860   jresult = (void *)result;
93861   return jresult;
93862 }
93863
93864
93865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
93866   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93867
93868   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93869   {
93870     try {
93871       delete arg1;
93872     } catch (std::out_of_range& e) {
93873       {
93874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93875       };
93876     } catch (std::exception& e) {
93877       {
93878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93879       };
93880     } catch (Dali::DaliException e) {
93881       {
93882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93883       };
93884     } catch (...) {
93885       {
93886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93887       };
93888     }
93889   }
93890
93891 }
93892
93893
93894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
93895   void * jresult ;
93896   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93897
93898   {
93899     try {
93900       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
93901     } catch (std::out_of_range& e) {
93902       {
93903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93904       };
93905     } catch (std::exception& e) {
93906       {
93907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93908       };
93909     } catch (Dali::DaliException e) {
93910       {
93911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93912       };
93913     } catch (...) {
93914       {
93915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93916       };
93917     }
93918   }
93919
93920   jresult = (void *)result;
93921   return jresult;
93922 }
93923
93924
93925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
93926   void * jresult ;
93927   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
93928   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93929
93930   arg1 = (Dali::Toolkit::Ruler *)jarg1;
93931   {
93932     try {
93933       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
93934     } catch (std::out_of_range& e) {
93935       {
93936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93937       };
93938     } catch (std::exception& e) {
93939       {
93940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93941       };
93942     } catch (Dali::DaliException e) {
93943       {
93944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93945       };
93946     } catch (...) {
93947       {
93948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93949       };
93950     }
93951   }
93952
93953   jresult = (void *)result;
93954   return jresult;
93955 }
93956
93957
93958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
93959   void * jresult ;
93960   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
93961   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93962
93963   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93964   if (!arg1) {
93965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93966     return 0;
93967   }
93968   {
93969     try {
93970       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
93971     } catch (std::out_of_range& e) {
93972       {
93973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93974       };
93975     } catch (std::exception& e) {
93976       {
93977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93978       };
93979     } catch (Dali::DaliException e) {
93980       {
93981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93982       };
93983     } catch (...) {
93984       {
93985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93986       };
93987     }
93988   }
93989
93990   jresult = (void *)result;
93991   return jresult;
93992 }
93993
93994
93995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
93996   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93997
93998   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93999   {
94000     try {
94001       delete arg1;
94002     } catch (std::out_of_range& e) {
94003       {
94004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94005       };
94006     } catch (std::exception& e) {
94007       {
94008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94009       };
94010     } catch (Dali::DaliException e) {
94011       {
94012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94013       };
94014     } catch (...) {
94015       {
94016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94017       };
94018     }
94019   }
94020
94021 }
94022
94023
94024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
94025   void * jresult ;
94026   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94027   Dali::Toolkit::Ruler *result = 0 ;
94028
94029   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94030   {
94031     try {
94032       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
94033     } catch (std::out_of_range& e) {
94034       {
94035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94036       };
94037     } catch (std::exception& e) {
94038       {
94039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94040       };
94041     } catch (Dali::DaliException e) {
94042       {
94043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94044       };
94045     } catch (...) {
94046       {
94047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94048       };
94049     }
94050   }
94051
94052   jresult = (void *)result;
94053   return jresult;
94054 }
94055
94056
94057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
94058   void * jresult ;
94059   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94060   Dali::Toolkit::Ruler *result = 0 ;
94061
94062   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94063   {
94064     try {
94065       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
94066     } catch (std::out_of_range& e) {
94067       {
94068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94069       };
94070     } catch (std::exception& e) {
94071       {
94072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94073       };
94074     } catch (Dali::DaliException e) {
94075       {
94076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94077       };
94078     } catch (...) {
94079       {
94080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94081       };
94082     }
94083   }
94084
94085   jresult = (void *)result;
94086   return jresult;
94087 }
94088
94089
94090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
94091   void * jresult ;
94092   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94093   Dali::Toolkit::Ruler *result = 0 ;
94094
94095   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94096   {
94097     try {
94098       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
94099     } catch (std::out_of_range& e) {
94100       {
94101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94102       };
94103     } catch (std::exception& e) {
94104       {
94105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94106       };
94107     } catch (Dali::DaliException e) {
94108       {
94109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94110       };
94111     } catch (...) {
94112       {
94113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94114       };
94115     }
94116   }
94117
94118   jresult = (void *)result;
94119   return jresult;
94120 }
94121
94122
94123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
94124   void * jresult ;
94125   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94126   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
94127   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94128
94129   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94130   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
94131   if (!arg2) {
94132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94133     return 0;
94134   }
94135   {
94136     try {
94137       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
94138     } catch (std::out_of_range& e) {
94139       {
94140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94141       };
94142     } catch (std::exception& e) {
94143       {
94144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94145       };
94146     } catch (Dali::DaliException e) {
94147       {
94148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94149       };
94150     } catch (...) {
94151       {
94152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94153       };
94154     }
94155   }
94156
94157   jresult = (void *)result;
94158   return jresult;
94159 }
94160
94161
94162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
94163   void * jresult ;
94164   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94165   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94166   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94167
94168   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94169   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94170   {
94171     try {
94172       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
94173     } catch (std::out_of_range& e) {
94174       {
94175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94176       };
94177     } catch (std::exception& e) {
94178       {
94179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94180       };
94181     } catch (Dali::DaliException e) {
94182       {
94183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94184       };
94185     } catch (...) {
94186       {
94187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94188       };
94189     }
94190   }
94191
94192   jresult = (void *)result;
94193   return jresult;
94194 }
94195
94196
94197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94198   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94199
94200   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94201   {
94202     try {
94203       (arg1)->Reset();
94204     } catch (std::out_of_range& e) {
94205       {
94206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94207       };
94208     } catch (std::exception& e) {
94209       {
94210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94211       };
94212     } catch (Dali::DaliException e) {
94213       {
94214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94215       };
94216     } catch (...) {
94217       {
94218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94219       };
94220     }
94221   }
94222
94223 }
94224
94225
94226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94227   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94228   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94229
94230   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94231   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94232   {
94233     try {
94234       (arg1)->Reset(arg2);
94235     } catch (std::out_of_range& e) {
94236       {
94237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94238       };
94239     } catch (std::exception& e) {
94240       {
94241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94242       };
94243     } catch (Dali::DaliException e) {
94244       {
94245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94246       };
94247     } catch (...) {
94248       {
94249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94250       };
94251     }
94252   }
94253
94254 }
94255
94256
94257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94258   void * jresult ;
94259   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94260   Dali::Toolkit::Ruler *result = 0 ;
94261
94262   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94263   {
94264     try {
94265       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94266     } catch (std::out_of_range& e) {
94267       {
94268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94269       };
94270     } catch (std::exception& e) {
94271       {
94272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94273       };
94274     } catch (Dali::DaliException e) {
94275       {
94276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94277       };
94278     } catch (...) {
94279       {
94280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94281       };
94282     }
94283   }
94284
94285   jresult = (void *)result;
94286   return jresult;
94287 }
94288
94289
94290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94291   float jresult ;
94292   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94293   float arg2 ;
94294   float arg3 ;
94295   float result;
94296
94297   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94298   arg2 = (float)jarg2;
94299   arg3 = (float)jarg3;
94300   {
94301     try {
94302       result = (float)(*arg1)->Snap(arg2,arg3);
94303     } catch (std::out_of_range& e) {
94304       {
94305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94306       };
94307     } catch (std::exception& e) {
94308       {
94309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94310       };
94311     } catch (Dali::DaliException e) {
94312       {
94313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94314       };
94315     } catch (...) {
94316       {
94317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94318       };
94319     }
94320   }
94321
94322   jresult = result;
94323   return jresult;
94324 }
94325
94326
94327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94328   float jresult ;
94329   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94330   float arg2 ;
94331   float result;
94332
94333   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94334   arg2 = (float)jarg2;
94335   {
94336     try {
94337       result = (float)(*arg1)->Snap(arg2);
94338     } catch (std::out_of_range& e) {
94339       {
94340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94341       };
94342     } catch (std::exception& e) {
94343       {
94344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94345       };
94346     } catch (Dali::DaliException e) {
94347       {
94348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94349       };
94350     } catch (...) {
94351       {
94352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94353       };
94354     }
94355   }
94356
94357   jresult = result;
94358   return jresult;
94359 }
94360
94361
94362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94363   float jresult ;
94364   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94365   unsigned int arg2 ;
94366   unsigned int *arg3 = 0 ;
94367   bool arg4 ;
94368   float result;
94369
94370   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94371   arg2 = (unsigned int)jarg2;
94372   arg3 = (unsigned int *)jarg3;
94373   arg4 = jarg4 ? true : false;
94374   {
94375     try {
94376       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94377     } catch (std::out_of_range& e) {
94378       {
94379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94380       };
94381     } catch (std::exception& e) {
94382       {
94383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94384       };
94385     } catch (Dali::DaliException e) {
94386       {
94387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94388       };
94389     } catch (...) {
94390       {
94391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94392       };
94393     }
94394   }
94395
94396   jresult = result;
94397   return jresult;
94398 }
94399
94400
94401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94402   unsigned int jresult ;
94403   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94404   float arg2 ;
94405   bool arg3 ;
94406   unsigned int result;
94407
94408   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94409   arg2 = (float)jarg2;
94410   arg3 = jarg3 ? true : false;
94411   {
94412     try {
94413       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94414     } catch (std::out_of_range& e) {
94415       {
94416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94417       };
94418     } catch (std::exception& e) {
94419       {
94420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94421       };
94422     } catch (Dali::DaliException e) {
94423       {
94424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94425       };
94426     } catch (...) {
94427       {
94428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94429       };
94430     }
94431   }
94432
94433   jresult = result;
94434   return jresult;
94435 }
94436
94437
94438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94439   unsigned int jresult ;
94440   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94441   unsigned int result;
94442
94443   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94444   {
94445     try {
94446       result = (unsigned int)(*arg1)->GetTotalPages();
94447     } catch (std::out_of_range& e) {
94448       {
94449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94450       };
94451     } catch (std::exception& e) {
94452       {
94453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94454       };
94455     } catch (Dali::DaliException e) {
94456       {
94457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94458       };
94459     } catch (...) {
94460       {
94461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94462       };
94463     }
94464   }
94465
94466   jresult = result;
94467   return jresult;
94468 }
94469
94470
94471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94472   int jresult ;
94473   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94474   Dali::Toolkit::Ruler::RulerType result;
94475
94476   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94477   {
94478     try {
94479       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
94480     } catch (std::out_of_range& e) {
94481       {
94482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94483       };
94484     } catch (std::exception& e) {
94485       {
94486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94487       };
94488     } catch (Dali::DaliException e) {
94489       {
94490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94491       };
94492     } catch (...) {
94493       {
94494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94495       };
94496     }
94497   }
94498
94499   jresult = (int)result;
94500   return jresult;
94501 }
94502
94503
94504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94505   unsigned int jresult ;
94506   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94507   bool result;
94508
94509   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94510   {
94511     try {
94512       result = (bool)(*arg1)->IsEnabled();
94513     } catch (std::out_of_range& e) {
94514       {
94515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94516       };
94517     } catch (std::exception& e) {
94518       {
94519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94520       };
94521     } catch (Dali::DaliException e) {
94522       {
94523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94524       };
94525     } catch (...) {
94526       {
94527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94528       };
94529     }
94530   }
94531
94532   jresult = result;
94533   return jresult;
94534 }
94535
94536
94537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94538   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94539
94540   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94541   {
94542     try {
94543       (*arg1)->Enable();
94544     } catch (std::out_of_range& e) {
94545       {
94546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94547       };
94548     } catch (std::exception& e) {
94549       {
94550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94551       };
94552     } catch (Dali::DaliException e) {
94553       {
94554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94555       };
94556     } catch (...) {
94557       {
94558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94559       };
94560     }
94561   }
94562
94563 }
94564
94565
94566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94567   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94568
94569   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94570   {
94571     try {
94572       (*arg1)->Disable();
94573     } catch (std::out_of_range& e) {
94574       {
94575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94576       };
94577     } catch (std::exception& e) {
94578       {
94579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94580       };
94581     } catch (Dali::DaliException e) {
94582       {
94583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94584       };
94585     } catch (...) {
94586       {
94587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94588       };
94589     }
94590   }
94591
94592 }
94593
94594
94595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94596   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94597   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94598   Dali::Toolkit::RulerDomain *argp2 ;
94599
94600   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94601   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94602   if (!argp2) {
94603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94604     return ;
94605   }
94606   arg2 = *argp2;
94607   {
94608     try {
94609       (*arg1)->SetDomain(arg2);
94610     } catch (std::out_of_range& e) {
94611       {
94612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94613       };
94614     } catch (std::exception& e) {
94615       {
94616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94617       };
94618     } catch (Dali::DaliException e) {
94619       {
94620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94621       };
94622     } catch (...) {
94623       {
94624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94625       };
94626     }
94627   }
94628
94629 }
94630
94631
94632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94633   void * jresult ;
94634   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94635   Dali::Toolkit::RulerDomain *result = 0 ;
94636
94637   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94638   {
94639     try {
94640       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94641     } catch (std::out_of_range& e) {
94642       {
94643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94644       };
94645     } catch (std::exception& e) {
94646       {
94647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94648       };
94649     } catch (Dali::DaliException e) {
94650       {
94651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94652       };
94653     } catch (...) {
94654       {
94655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94656       };
94657     }
94658   }
94659
94660   jresult = (void *)result;
94661   return jresult;
94662 }
94663
94664
94665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94666   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94667
94668   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94669   {
94670     try {
94671       (*arg1)->DisableDomain();
94672     } catch (std::out_of_range& e) {
94673       {
94674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94675       };
94676     } catch (std::exception& e) {
94677       {
94678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94679       };
94680     } catch (Dali::DaliException e) {
94681       {
94682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94683       };
94684     } catch (...) {
94685       {
94686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94687       };
94688     }
94689   }
94690
94691 }
94692
94693
94694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
94695   float jresult ;
94696   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94697   float arg2 ;
94698   float arg3 ;
94699   float arg4 ;
94700   float result;
94701
94702   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94703   arg2 = (float)jarg2;
94704   arg3 = (float)jarg3;
94705   arg4 = (float)jarg4;
94706   {
94707     try {
94708       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
94709     } catch (std::out_of_range& e) {
94710       {
94711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94712       };
94713     } catch (std::exception& e) {
94714       {
94715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94716       };
94717     } catch (Dali::DaliException e) {
94718       {
94719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94720       };
94721     } catch (...) {
94722       {
94723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94724       };
94725     }
94726   }
94727
94728   jresult = result;
94729   return jresult;
94730 }
94731
94732
94733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
94734   float jresult ;
94735   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94736   float arg2 ;
94737   float arg3 ;
94738   float result;
94739
94740   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94741   arg2 = (float)jarg2;
94742   arg3 = (float)jarg3;
94743   {
94744     try {
94745       result = (float)(*arg1)->Clamp(arg2,arg3);
94746     } catch (std::out_of_range& e) {
94747       {
94748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94749       };
94750     } catch (std::exception& e) {
94751       {
94752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94753       };
94754     } catch (Dali::DaliException e) {
94755       {
94756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94757       };
94758     } catch (...) {
94759       {
94760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94761       };
94762     }
94763   }
94764
94765   jresult = result;
94766   return jresult;
94767 }
94768
94769
94770 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
94771   float jresult ;
94772   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94773   float arg2 ;
94774   float result;
94775
94776   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94777   arg2 = (float)jarg2;
94778   {
94779     try {
94780       result = (float)(*arg1)->Clamp(arg2);
94781     } catch (std::out_of_range& e) {
94782       {
94783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94784       };
94785     } catch (std::exception& e) {
94786       {
94787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94788       };
94789     } catch (Dali::DaliException e) {
94790       {
94791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94792       };
94793     } catch (...) {
94794       {
94795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94796       };
94797     }
94798   }
94799
94800   jresult = result;
94801   return jresult;
94802 }
94803
94804
94805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
94806   float jresult ;
94807   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94808   float arg2 ;
94809   float arg3 ;
94810   float arg4 ;
94811   Dali::Toolkit::ClampState *arg5 = 0 ;
94812   float result;
94813
94814   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94815   arg2 = (float)jarg2;
94816   arg3 = (float)jarg3;
94817   arg4 = (float)jarg4;
94818   arg5 = (Dali::Toolkit::ClampState *)jarg5;
94819   if (!arg5) {
94820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94821     return 0;
94822   }
94823   {
94824     try {
94825       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
94826     } catch (std::out_of_range& e) {
94827       {
94828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94829       };
94830     } catch (std::exception& e) {
94831       {
94832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94833       };
94834     } catch (Dali::DaliException e) {
94835       {
94836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94837       };
94838     } catch (...) {
94839       {
94840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94841       };
94842     }
94843   }
94844
94845   jresult = result;
94846   return jresult;
94847 }
94848
94849
94850 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
94851   float jresult ;
94852   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94853   float arg2 ;
94854   float arg3 ;
94855   float arg4 ;
94856   float arg5 ;
94857   float result;
94858
94859   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94860   arg2 = (float)jarg2;
94861   arg3 = (float)jarg3;
94862   arg4 = (float)jarg4;
94863   arg5 = (float)jarg5;
94864   {
94865     try {
94866       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
94867     } catch (std::out_of_range& e) {
94868       {
94869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94870       };
94871     } catch (std::exception& e) {
94872       {
94873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94874       };
94875     } catch (Dali::DaliException e) {
94876       {
94877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94878       };
94879     } catch (...) {
94880       {
94881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94882       };
94883     }
94884   }
94885
94886   jresult = result;
94887   return jresult;
94888 }
94889
94890
94891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
94892   float jresult ;
94893   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94894   float arg2 ;
94895   float arg3 ;
94896   float arg4 ;
94897   float result;
94898
94899   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94900   arg2 = (float)jarg2;
94901   arg3 = (float)jarg3;
94902   arg4 = (float)jarg4;
94903   {
94904     try {
94905       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
94906     } catch (std::out_of_range& e) {
94907       {
94908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94909       };
94910     } catch (std::exception& e) {
94911       {
94912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94913       };
94914     } catch (Dali::DaliException e) {
94915       {
94916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94917       };
94918     } catch (...) {
94919       {
94920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94921       };
94922     }
94923   }
94924
94925   jresult = result;
94926   return jresult;
94927 }
94928
94929
94930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
94931   float jresult ;
94932   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94933   float arg2 ;
94934   float arg3 ;
94935   float result;
94936
94937   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94938   arg2 = (float)jarg2;
94939   arg3 = (float)jarg3;
94940   {
94941     try {
94942       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
94943     } catch (std::out_of_range& e) {
94944       {
94945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94946       };
94947     } catch (std::exception& e) {
94948       {
94949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94950       };
94951     } catch (Dali::DaliException e) {
94952       {
94953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94954       };
94955     } catch (...) {
94956       {
94957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94958       };
94959     }
94960   }
94961
94962   jresult = result;
94963   return jresult;
94964 }
94965
94966
94967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
94968   float jresult ;
94969   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94970   float arg2 ;
94971   float result;
94972
94973   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94974   arg2 = (float)jarg2;
94975   {
94976     try {
94977       result = (float)(*arg1)->SnapAndClamp(arg2);
94978     } catch (std::out_of_range& e) {
94979       {
94980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94981       };
94982     } catch (std::exception& e) {
94983       {
94984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94985       };
94986     } catch (Dali::DaliException e) {
94987       {
94988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94989       };
94990     } catch (...) {
94991       {
94992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94993       };
94994     }
94995   }
94996
94997   jresult = result;
94998   return jresult;
94999 }
95000
95001
95002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
95003   float jresult ;
95004   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95005   float arg2 ;
95006   float arg3 ;
95007   float arg4 ;
95008   float arg5 ;
95009   Dali::Toolkit::ClampState *arg6 = 0 ;
95010   float result;
95011
95012   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95013   arg2 = (float)jarg2;
95014   arg3 = (float)jarg3;
95015   arg4 = (float)jarg4;
95016   arg5 = (float)jarg5;
95017   arg6 = (Dali::Toolkit::ClampState *)jarg6;
95018   if (!arg6) {
95019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95020     return 0;
95021   }
95022   {
95023     try {
95024       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
95025     } catch (std::out_of_range& e) {
95026       {
95027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95028       };
95029     } catch (std::exception& e) {
95030       {
95031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95032       };
95033     } catch (Dali::DaliException e) {
95034       {
95035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95036       };
95037     } catch (...) {
95038       {
95039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95040       };
95041     }
95042   }
95043
95044   jresult = result;
95045   return jresult;
95046 }
95047
95048
95049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
95050   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95051
95052   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95053   {
95054     try {
95055       (*arg1)->Reference();
95056     } catch (std::out_of_range& e) {
95057       {
95058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95059       };
95060     } catch (std::exception& e) {
95061       {
95062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95063       };
95064     } catch (Dali::DaliException e) {
95065       {
95066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95067       };
95068     } catch (...) {
95069       {
95070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95071       };
95072     }
95073   }
95074
95075 }
95076
95077
95078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
95079   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95080
95081   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95082   {
95083     try {
95084       (*arg1)->Unreference();
95085     } catch (std::out_of_range& e) {
95086       {
95087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95088       };
95089     } catch (std::exception& e) {
95090       {
95091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95092       };
95093     } catch (Dali::DaliException e) {
95094       {
95095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95096       };
95097     } catch (...) {
95098       {
95099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95100       };
95101     }
95102   }
95103
95104 }
95105
95106
95107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
95108   int jresult ;
95109   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95110   int result;
95111
95112   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95113   {
95114     try {
95115       result = (int)(*arg1)->ReferenceCount();
95116     } catch (std::out_of_range& e) {
95117       {
95118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95119       };
95120     } catch (std::exception& e) {
95121       {
95122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95123       };
95124     } catch (Dali::DaliException e) {
95125       {
95126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95127       };
95128     } catch (...) {
95129       {
95130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95131       };
95132     }
95133   }
95134
95135   jresult = result;
95136   return jresult;
95137 }
95138
95139
95140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
95141   unsigned int jresult ;
95142   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95143   bool result;
95144
95145   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95146   {
95147     try {
95148       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95149     } catch (std::out_of_range& e) {
95150       {
95151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95152       };
95153     } catch (std::exception& e) {
95154       {
95155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95156       };
95157     } catch (Dali::DaliException e) {
95158       {
95159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95160       };
95161     } catch (...) {
95162       {
95163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95164       };
95165     }
95166   }
95167
95168   jresult = result;
95169   return jresult;
95170 }
95171
95172
95173 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
95174   unsigned long jresult ;
95175   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95176   std::size_t result;
95177
95178   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95179   {
95180     try {
95181       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95182     } catch (std::out_of_range& e) {
95183       {
95184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95185       };
95186     } catch (std::exception& e) {
95187       {
95188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95189       };
95190     } catch (Dali::DaliException e) {
95191       {
95192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95193       };
95194     } catch (...) {
95195       {
95196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95197       };
95198     }
95199   }
95200
95201   jresult = (unsigned long)result;
95202   return jresult;
95203 }
95204
95205
95206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95207   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95208   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95209
95210   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95211   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95212   {
95213     try {
95214       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95215     } catch (std::out_of_range& e) {
95216       {
95217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95218       };
95219     } catch (std::exception& e) {
95220       {
95221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95222       };
95223     } catch (Dali::DaliException e) {
95224       {
95225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95226       };
95227     } catch (...) {
95228       {
95229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95230       };
95231     }
95232   }
95233
95234 }
95235
95236
95237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95238   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95239   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95240
95241   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95242   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95243   {
95244     try {
95245       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95246     } catch (std::out_of_range& e) {
95247       {
95248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95249       };
95250     } catch (std::exception& e) {
95251       {
95252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95253       };
95254     } catch (Dali::DaliException e) {
95255       {
95256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95257       };
95258     } catch (...) {
95259       {
95260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95261       };
95262     }
95263   }
95264
95265 }
95266
95267
95268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95269   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95270   Dali::Toolkit::Control arg2 ;
95271   Dali::Toolkit::Control *argp2 ;
95272
95273   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95274   argp2 = (Dali::Toolkit::Control *)jarg2;
95275   if (!argp2) {
95276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95277     return ;
95278   }
95279   arg2 = *argp2;
95280   {
95281     try {
95282       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95283     } catch (std::out_of_range& e) {
95284       {
95285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95286       };
95287     } catch (std::exception& e) {
95288       {
95289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95290       };
95291     } catch (Dali::DaliException e) {
95292       {
95293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95294       };
95295     } catch (...) {
95296       {
95297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95298       };
95299     }
95300   }
95301
95302 }
95303
95304
95305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95306   void * jresult ;
95307   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95308
95309   {
95310     try {
95311       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95312     } catch (std::out_of_range& e) {
95313       {
95314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95315       };
95316     } catch (std::exception& e) {
95317       {
95318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95319       };
95320     } catch (Dali::DaliException e) {
95321       {
95322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95323       };
95324     } catch (...) {
95325       {
95326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95327       };
95328     }
95329   }
95330
95331   jresult = (void *)result;
95332   return jresult;
95333 }
95334
95335
95336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95337   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95338
95339   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95340   {
95341     try {
95342       delete arg1;
95343     } catch (std::out_of_range& e) {
95344       {
95345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95346       };
95347     } catch (std::exception& e) {
95348       {
95349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95350       };
95351     } catch (Dali::DaliException e) {
95352       {
95353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95354       };
95355     } catch (...) {
95356       {
95357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95358       };
95359     }
95360   }
95361
95362 }
95363
95364 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95365   Dali::RefObject *result = NULL;
95366
95367   if (arg1)
95368   {
95369     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95370   }
95371   return result;
95372 }
95373
95374 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95375     return (Dali::RefObject *)jarg1;
95376 }
95377
95378 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95379     return (Dali::SignalObserver *)jarg1;
95380 }
95381
95382 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95383     return (Dali::ConnectionTrackerInterface *)jarg1;
95384 }
95385
95386 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95387     return (Dali::BaseHandle *)jarg1;
95388 }
95389
95390 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95391     return (Dali::BaseHandle *)jarg1;
95392 }
95393
95394 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95395     return (Dali::BaseHandle *)jarg1;
95396 }
95397
95398 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95399     return (Dali::BaseHandle *)jarg1;
95400 }
95401
95402 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95403     return (Dali::BaseHandle *)jarg1;
95404 }
95405
95406 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95407     return (Dali::BaseHandle *)jarg1;
95408 }
95409
95410 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95411     return (Dali::BaseHandle *)jarg1;
95412 }
95413
95414 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95415     return (Dali::BaseHandle *)jarg1;
95416 }
95417
95418 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95419     return (Dali::BaseHandle *)jarg1;
95420 }
95421
95422 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95423     return (Dali::BaseHandle *)jarg1;
95424 }
95425
95426 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
95427     return (Dali::BaseHandle *)jarg1;
95428 }
95429
95430 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95431     return (Dali::BaseHandle *)jarg1;
95432 }
95433
95434 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95435     return (Dali::Handle *)jarg1;
95436 }
95437
95438 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95439     return (Dali::Handle *)jarg1;
95440 }
95441
95442 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95443     return (Dali::BaseHandle *)jarg1;
95444 }
95445
95446 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95447     return (Dali::BaseHandle *)jarg1;
95448 }
95449
95450 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95451     return (Dali::Handle *)jarg1;
95452 }
95453
95454 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
95455     return (Dali::BaseHandle *)jarg1;
95456 }
95457
95458 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95459     return (Dali::Handle *)jarg1;
95460 }
95461
95462 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95463     return (Dali::GestureDetector *)jarg1;
95464 }
95465
95466 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95467     return (Dali::Gesture *)jarg1;
95468 }
95469
95470 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95471     return (Dali::Handle *)jarg1;
95472 }
95473
95474 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95475     return (Dali::Actor *)jarg1;
95476 }
95477
95478 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95479     return (Dali::RefObject *)jarg1;
95480 }
95481
95482 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95483     return (Dali::Actor *)jarg1;
95484 }
95485
95486 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95487     return (Dali::GestureDetector *)jarg1;
95488 }
95489
95490 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95491     return (Dali::Gesture *)jarg1;
95492 }
95493
95494 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95495     return (Dali::GestureDetector *)jarg1;
95496 }
95497
95498 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95499     return (Dali::Gesture *)jarg1;
95500 }
95501
95502 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95503     return (Dali::GestureDetector *)jarg1;
95504 }
95505
95506 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95507     return (Dali::Gesture *)jarg1;
95508 }
95509
95510 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95511     return (Dali::BaseHandle *)jarg1;
95512 }
95513
95514 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95515     return (Dali::Handle *)jarg1;
95516 }
95517
95518 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95519     return (Dali::Handle *)jarg1;
95520 }
95521
95522 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95523     return (Dali::Handle *)jarg1;
95524 }
95525
95526 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95527     return (Dali::RefObject *)jarg1;
95528 }
95529
95530 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95531     return (Dali::Actor *)jarg1;
95532 }
95533
95534 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95535     return (Dali::BaseHandle *)jarg1;
95536 }
95537
95538 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95539     return (Dali::BaseHandle *)jarg1;
95540 }
95541
95542 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95543     return (Dali::BaseHandle *)jarg1;
95544 }
95545
95546 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95547     return (Dali::CustomActorImpl *)jarg1;
95548 }
95549
95550 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95551     return (Dali::CustomActor *)jarg1;
95552 }
95553
95554 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95555     return (Dali::BaseHandle *)jarg1;
95556 }
95557
95558 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95559     return (Dali::Toolkit::Control *)jarg1;
95560 }
95561
95562 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95563     return (Dali::Toolkit::Control *)jarg1;
95564 }
95565
95566 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95567     return (Dali::Toolkit::Button *)jarg1;
95568 }
95569
95570 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95571     return (Dali::Toolkit::Button *)jarg1;
95572 }
95573
95574 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95575     return (Dali::Toolkit::Button *)jarg1;
95576 }
95577
95578 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95579     return (Dali::Toolkit::Control *)jarg1;
95580 }
95581
95582 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95583     return (Dali::Toolkit::Control *)jarg1;
95584 }
95585
95586 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95587     return (Dali::Toolkit::Control *)jarg1;
95588 }
95589
95590 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95591     return (Dali::Toolkit::Control *)jarg1;
95592 }
95593
95594 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95595     return (Dali::Toolkit::Control *)jarg1;
95596 }
95597
95598 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95599     return (Dali::RefObject *)jarg1;
95600 }
95601
95602 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95603     return (Dali::Toolkit::Scrollable *)jarg1;
95604 }
95605
95606 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95607     return (Dali::BaseHandle *)jarg1;
95608 }
95609
95610 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95611     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95612 }
95613
95614 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95615     return (Dali::RefObject *)jarg1;
95616 }
95617
95618 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95619     return (Dali::Toolkit::Ruler *)jarg1;
95620 }
95621
95622 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95623     return (Dali::Toolkit::Ruler *)jarg1;
95624 }
95625
95626 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95627     return (Dali::Toolkit::Scrollable *)jarg1;
95628 }
95629
95630 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95631     return (Dali::Toolkit::Control *)jarg1;
95632 }
95633
95634
95635 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95636     return (Dali::Toolkit::Control *)jarg1;
95637 }
95638
95639 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95640     return (Dali::BaseHandle *)jarg1;
95641 }
95642
95643 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95644     return (Dali::BaseHandle *)jarg1;
95645 }
95646
95647 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95648     return (Dali::Toolkit::Control *)jarg1;
95649 }
95650
95651 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95652     return (Dali::Toolkit::Control *)jarg1;
95653 }
95654
95655 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95656     return (Dali::Toolkit::Control *)jarg1;
95657 }
95658
95659 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95660     return (Dali::Toolkit::Control *)jarg1;
95661 }
95662
95663 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95664     return (Dali::Toolkit::Control *)jarg1;
95665 }
95666
95667 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95668     return (Dali::Toolkit::Control *)jarg1;
95669 }
95670
95671 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95672     return (Dali::Toolkit::PageTurnView *)jarg1;
95673 }
95674
95675 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95676     return (Dali::Toolkit::PageTurnView *)jarg1;
95677 }
95678
95679 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
95680     return (Dali::Toolkit::Button *)jarg1;
95681 }
95682
95683 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
95684     return (Dali::BaseHandle *)jarg1;
95685 }
95686
95687 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
95688     return (Dali::BaseHandle *)jarg1;
95689 }
95690
95691 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
95692     return (Dali::BaseHandle *)jarg1;
95693 }
95694
95695 /*
95696  * Widget binding
95697  */
95698 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
95699     return (Dali::BaseHandle *)jarg1;
95700 }
95701
95702 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
95703     return (Dali::BaseObject *)jarg1;
95704 }
95705
95706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
95707   void * jresult ;
95708   Dali::Widget result;
95709
95710   {
95711     try {
95712       result = Dali::Widget::New();
95713     } catch (std::out_of_range& e) {
95714       {
95715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95716       };
95717     } catch (std::exception& e) {
95718       {
95719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95720       };
95721     } catch (...) {
95722       {
95723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95724       };
95725     }
95726   }
95727   jresult = new Dali::Widget((const Dali::Widget &)result);
95728   return jresult;
95729 }
95730
95731
95732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
95733   void * jresult ;
95734   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
95735   Dali::Widget result;
95736
95737   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95738
95739   if (!arg1) {
95740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
95741     return 0;
95742   }
95743   {
95744     try {
95745       jresult = new Dali::Widget(arg1);
95746     } catch (std::out_of_range& e) {
95747       {
95748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95749       };
95750     } catch (std::exception& e) {
95751       {
95752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95753       };
95754     } catch (...) {
95755       {
95756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95757       };
95758     }
95759   }
95760   return jresult;
95761 }
95762
95763
95764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
95765   void * jresult ;
95766   Dali::Widget *result = 0 ;
95767
95768   {
95769     try {
95770       result = (Dali::Widget *)new Dali::Widget();
95771     } catch (std::out_of_range& e) {
95772       {
95773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95774       };
95775     } catch (std::exception& e) {
95776       {
95777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95778       };
95779     } catch (...) {
95780       {
95781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95782       };
95783     }
95784   }
95785   jresult = (void *)result;
95786   return jresult;
95787 }
95788
95789
95790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
95791   void * jresult ;
95792   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95793   Dali::Widget *arg2 = 0 ;
95794   Dali::Widget *result = 0 ;
95795
95796   arg1 = (Dali::Widget *)jarg1;
95797   arg2 = (Dali::Widget *)jarg2;
95798   if (!arg2) {
95799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
95800     return 0;
95801   }
95802   {
95803     try {
95804       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
95805     } catch (std::out_of_range& e) {
95806       {
95807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95808       };
95809     } catch (std::exception& e) {
95810       {
95811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95812       };
95813     } catch (...) {
95814       {
95815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95816       };
95817     }
95818   }
95819   jresult = (void *)result;
95820   return jresult;
95821 }
95822
95823
95824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
95825   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95826
95827   arg1 = (Dali::Widget *)jarg1;
95828   {
95829     try {
95830       delete arg1;
95831     } catch (std::out_of_range& e) {
95832       {
95833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95834       };
95835     } catch (std::exception& e) {
95836       {
95837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95838       };
95839     } catch (...) {
95840       {
95841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95842       };
95843     }
95844   }
95845 }
95846
95847
95848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
95849   void * jresult ;
95850   SwigDirector_WidgetImpl* result;
95851   {
95852     try {
95853       result = new SwigDirector_WidgetImpl();
95854     } catch (std::out_of_range& e) {
95855       {
95856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95857       };
95858     } catch (std::exception& e) {
95859       {
95860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95861       };
95862     } catch (...) {
95863       {
95864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95865       };
95866     }
95867   }
95868   jresult = result;
95869   return jresult;
95870 }
95871
95872
95873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
95874   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95875   std::string *arg2 = 0 ;
95876   Dali::Window arg3 ;
95877   Dali::Window *argp3 ;
95878
95879   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95880   if (!jarg2) {
95881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95882     return ;
95883   }
95884   std::string arg2_str(jarg2);
95885   arg2 = &arg2_str;
95886   argp3 = (Dali::Window *)jarg3;
95887   if (!argp3) {
95888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95889     return ;
95890   }
95891   arg3 = *argp3;
95892   {
95893     try {
95894       (arg1)->OnCreate((std::string const &)*arg2,arg3);
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 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
95912   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95913   std::string *arg2 = 0 ;
95914   Dali::Window arg3 ;
95915   Dali::Window *argp3 ;
95916
95917   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95918   if (!jarg2) {
95919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95920     return ;
95921   }
95922   std::string arg2_str(jarg2);
95923   arg2 = &arg2_str;
95924   argp3 = (Dali::Window *)jarg3;
95925   if (!argp3) {
95926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95927     return ;
95928   }
95929   arg3 = *argp3;
95930   {
95931     try {
95932       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
95933     } catch (std::out_of_range& e) {
95934       {
95935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95936       };
95937     } catch (std::exception& e) {
95938       {
95939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95940       };
95941     } catch (...) {
95942       {
95943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95944       };
95945     }
95946   }
95947 }
95948
95949
95950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
95951   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95952   std::string *arg2 = 0 ;
95953   Dali::Widget::Termination arg3 ;
95954
95955   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95956   if (!jarg2) {
95957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95958     return ;
95959   }
95960   std::string arg2_str(jarg2);
95961   arg2 = &arg2_str;
95962   arg3 = (Dali::Widget::Termination)jarg3;
95963   {
95964     try {
95965       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
95966     } catch (std::out_of_range& e) {
95967       {
95968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95969       };
95970     } catch (std::exception& e) {
95971       {
95972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95973       };
95974     } catch (...) {
95975       {
95976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95977       };
95978     }
95979   }
95980 }
95981
95982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
95983   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95984   std::string *arg2 = 0 ;
95985   Dali::Widget::Termination arg3 ;
95986
95987   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95988   if (!jarg2) {
95989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95990     return ;
95991   }
95992   std::string arg2_str(jarg2);
95993   arg2 = &arg2_str;
95994   arg3 = (Dali::Widget::Termination)jarg3;
95995   {
95996     try {
95997       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
95998     } catch (std::out_of_range& e) {
95999       {
96000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96001       };
96002     } catch (std::exception& e) {
96003       {
96004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96005       };
96006     } catch (...) {
96007       {
96008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96009       };
96010     }
96011   }
96012 }
96013
96014
96015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
96016   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96017
96018   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96019   {
96020     try {
96021       (arg1)->OnPause();
96022     } catch (std::out_of_range& e) {
96023       {
96024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96025       };
96026     } catch (std::exception& e) {
96027       {
96028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96029       };
96030     } catch (...) {
96031       {
96032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96033       };
96034     }
96035   }
96036 }
96037
96038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
96039   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96040
96041   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96042   {
96043     try {
96044       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
96045     } catch (std::out_of_range& e) {
96046       {
96047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96048       };
96049     } catch (std::exception& e) {
96050       {
96051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96052       };
96053     } catch (...) {
96054       {
96055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96056       };
96057     }
96058   }
96059 }
96060
96061
96062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
96063   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96064
96065   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96066   {
96067     try {
96068       (arg1)->OnResume();
96069     } catch (std::out_of_range& e) {
96070       {
96071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96072       };
96073     } catch (std::exception& e) {
96074       {
96075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96076       };
96077     } catch (...) {
96078       {
96079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96080       };
96081     }
96082   }
96083 }
96084
96085
96086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
96087   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96088
96089   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96090   {
96091     try {
96092       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
96093     } catch (std::out_of_range& e) {
96094       {
96095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96096       };
96097     } catch (std::exception& e) {
96098       {
96099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96100       };
96101     } catch (...) {
96102       {
96103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96104       };
96105     }
96106   }
96107 }
96108
96109
96110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
96111   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96112   Dali::Window arg2 ;
96113   Dali::Window *argp2 ;
96114
96115   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96116   argp2 = (Dali::Window *)jarg2;
96117   if (!argp2) {
96118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96119     return ;
96120   }
96121   arg2 = *argp2;
96122   {
96123     try {
96124       (arg1)->OnResize(arg2);
96125     } catch (std::out_of_range& e) {
96126       {
96127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96128       };
96129     } catch (std::exception& e) {
96130       {
96131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96132       };
96133     } catch (...) {
96134       {
96135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96136       };
96137     }
96138   }
96139 }
96140
96141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
96142   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96143   Dali::Window arg2 ;
96144   Dali::Window *argp2 ;
96145
96146   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96147   argp2 = (Dali::Window *)jarg2;
96148   if (!argp2) {
96149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96150     return ;
96151   }
96152   arg2 = *argp2;
96153   {
96154     try {
96155       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
96156     } catch (std::out_of_range& e) {
96157       {
96158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96159       };
96160     } catch (std::exception& e) {
96161       {
96162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96163       };
96164     } catch (...) {
96165       {
96166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96167       };
96168     }
96169   }
96170 }
96171
96172
96173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
96174   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96175   std::string *arg2 = 0 ;
96176   int arg3 ;
96177
96178   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96179   if (!jarg2) {
96180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96181     return ;
96182   }
96183   std::string arg2_str(jarg2);
96184   arg2 = &arg2_str;
96185   arg3 = (int)jarg3;
96186   {
96187     try {
96188       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96189     } catch (std::out_of_range& e) {
96190       {
96191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96192       };
96193     } catch (std::exception& e) {
96194       {
96195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96196       };
96197     } catch (...) {
96198       {
96199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96200       };
96201     }
96202   }
96203 }
96204
96205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96206   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96207   std::string *arg2 = 0 ;
96208   int arg3 ;
96209
96210   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96211   if (!jarg2) {
96212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96213     return ;
96214   }
96215   std::string arg2_str(jarg2);
96216   arg2 = &arg2_str;
96217   arg3 = (int)jarg3;
96218   {
96219     try {
96220       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96221     } catch (std::out_of_range& e) {
96222       {
96223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96224       };
96225     } catch (std::exception& e) {
96226       {
96227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96228       };
96229     } catch (...) {
96230       {
96231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96232       };
96233     }
96234   }
96235 }
96236
96237
96238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96239   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96240   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96241   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96242
96243   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96244   arg2 = (Dali::SlotObserver *)jarg2;
96245   arg3 = (Dali::CallbackBase *)jarg3;
96246   {
96247     try {
96248       (arg1)->SignalConnected(arg2,arg3);
96249     } catch (std::out_of_range& e) {
96250       {
96251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96252       };
96253     } catch (std::exception& e) {
96254       {
96255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96256       };
96257     } catch (...) {
96258       {
96259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96260       };
96261     }
96262   }
96263 }
96264
96265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96266   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96267   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96268   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96269
96270   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96271   arg2 = (Dali::SlotObserver *)jarg2;
96272   arg3 = (Dali::CallbackBase *)jarg3;
96273   {
96274     try {
96275       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96276     } catch (std::out_of_range& e) {
96277       {
96278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96279       };
96280     } catch (std::exception& e) {
96281       {
96282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96283       };
96284     } catch (...) {
96285       {
96286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96287       };
96288     }
96289   }
96290 }
96291
96292
96293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96294   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96295   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96296   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96297
96298   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96299   arg2 = (Dali::SlotObserver *)jarg2;
96300   arg3 = (Dali::CallbackBase *)jarg3;
96301   {
96302     try {
96303       (arg1)->SignalDisconnected(arg2,arg3);
96304     } catch (std::out_of_range& e) {
96305       {
96306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96307       };
96308     } catch (std::exception& e) {
96309       {
96310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96311       };
96312     } catch (...) {
96313       {
96314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96315       };
96316     }
96317   }
96318 }
96319
96320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96321   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96322   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96323   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96324
96325   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96326   arg2 = (Dali::SlotObserver *)jarg2;
96327   arg3 = (Dali::CallbackBase *)jarg3;
96328   {
96329     try {
96330       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96331     } catch (std::out_of_range& e) {
96332       {
96333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96334       };
96335     } catch (std::exception& e) {
96336       {
96337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96338       };
96339     } catch (...) {
96340       {
96341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96342       };
96343     }
96344   }
96345 }
96346
96347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96348   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96349   std::string *arg2 = 0 ;
96350
96351   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96352   if (!jarg2) {
96353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96354     return ;
96355   }
96356   std::string arg2_str(jarg2);
96357   arg2 = &arg2_str;
96358   {
96359     try {
96360       (arg1)->SetContentInfo((std::string const &)*arg2);
96361     } catch (std::out_of_range& e) {
96362       {
96363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96364       };
96365     } catch (std::exception& e) {
96366       {
96367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96368       };
96369     } catch (...) {
96370       {
96371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96372       };
96373     }
96374   }
96375 }
96376
96377
96378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96379   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96380   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96381
96382   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96383   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96384   {
96385     try {
96386       (arg1)->SetImpl(arg2);
96387     } catch (std::out_of_range& e) {
96388       {
96389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96390       };
96391     } catch (std::exception& e) {
96392       {
96393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96394       };
96395     } catch (...) {
96396       {
96397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96398       };
96399     }
96400   }
96401 }
96402
96403 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) {
96404
96405   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96406   if (director) {
96407     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96408   }
96409 }
96410
96411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96412   void * jresult ;
96413   Dali::Widget *arg1 = 0 ;
96414   SwigDirector_WidgetImpl *result = 0 ;
96415
96416   arg1 = (Dali::Widget *)jarg1;
96417   if (!arg1) {
96418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96419     return 0;
96420   }
96421   {
96422     try {
96423       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96424     } catch (std::out_of_range& e) {
96425       {
96426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96427       };
96428     } catch (std::exception& e) {
96429       {
96430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96431       };
96432     } catch (...) {
96433       {
96434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96435       };
96436     }
96437   }
96438
96439   jresult = (void *)result;
96440   return jresult;
96441 }
96442
96443
96444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96445   void * jresult ;
96446   int *arg1 = (int *) 0 ;
96447   char ***arg2 ;
96448   std::string *arg3 = 0 ;
96449   Dali::WidgetApplication result;
96450   {
96451     int index = 0;
96452     int length = 0;
96453     char *retPtr;
96454     char *nextPtr;
96455     argWidgetC = jarg1;
96456     argWidgetV = new char*[jarg1 + 1];
96457
96458     retPtr = strtok_r( jarg2, " ", &nextPtr);
96459     if( retPtr )
96460     {
96461       length = strlen(retPtr);
96462     }
96463     argWidgetV[index] = new char[length + 1];
96464     if( retPtr )
96465     {
96466       strncpy(argWidgetV[index], retPtr, length);
96467     }
96468     argWidgetV[index][length] = '\0';
96469     index++;
96470
96471     while (index < jarg1)
96472     {
96473       length = 0;
96474       retPtr = strtok_r(NULL, " ", &nextPtr);
96475       if( retPtr )
96476       {
96477         length = strlen(retPtr);
96478       }
96479       argWidgetV[index] = new char[length + 1];
96480       if( retPtr )
96481       {
96482         strncpy(argWidgetV[index], retPtr, length);
96483       }
96484       argWidgetV[index][length] = '\0';
96485       index++;
96486     }
96487
96488     argWidgetV[jarg1] = NULL;
96489     argWidgetC = jarg1;
96490
96491     arg1 = &argWidgetC;
96492     arg2 = &argWidgetV;
96493   }
96494
96495   if (!jarg3) {
96496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96497     return 0;
96498   }
96499   std::string arg3_str(jarg3);
96500   arg3 = &arg3_str;
96501   {
96502     try {
96503       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
96504     } catch (std::out_of_range& e) {
96505       {
96506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96507       };
96508     } catch (std::exception& e) {
96509       {
96510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96511       };
96512     } catch (...) {
96513       {
96514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96515       };
96516     }
96517   }
96518   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
96519
96520   return jresult;
96521 }
96522
96523
96524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96525   void * jresult ;
96526   Dali::WidgetApplication *result = 0 ;
96527
96528   {
96529     try {
96530       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96531     } catch (std::out_of_range& e) {
96532       {
96533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96534       };
96535     } catch (std::exception& e) {
96536       {
96537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96538       };
96539     } catch (...) {
96540       {
96541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96542       };
96543     }
96544   }
96545   jresult = (void *)result;
96546   return jresult;
96547 }
96548
96549
96550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96551   void * jresult ;
96552   Dali::WidgetApplication *arg1 = 0 ;
96553   Dali::WidgetApplication *result = 0 ;
96554
96555   arg1 = (Dali::WidgetApplication *)jarg1;
96556   if (!arg1) {
96557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96558     return 0;
96559   }
96560   {
96561     try {
96562       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
96563     } catch (std::out_of_range& e) {
96564       {
96565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96566       };
96567     } catch (std::exception& e) {
96568       {
96569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96570       };
96571     } catch (...) {
96572       {
96573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96574       };
96575     }
96576   }
96577   jresult = (void *)result;
96578   return jresult;
96579 }
96580
96581
96582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96583   void * jresult ;
96584   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96585   Dali::WidgetApplication *arg2 = 0 ;
96586   Dali::WidgetApplication *result = 0 ;
96587
96588   arg1 = (Dali::WidgetApplication *)jarg1;
96589   arg2 = (Dali::WidgetApplication *)jarg2;
96590   if (!arg2) {
96591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96592     return 0;
96593   }
96594   {
96595     try {
96596       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
96597     } catch (std::out_of_range& e) {
96598       {
96599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96600       };
96601     } catch (std::exception& e) {
96602       {
96603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96604       };
96605     } catch (...) {
96606       {
96607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96608       };
96609     }
96610   }
96611   jresult = (void *)result;
96612   return jresult;
96613 }
96614
96615
96616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96617   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96618
96619   arg1 = (Dali::WidgetApplication *)jarg1;
96620   {
96621     try {
96622       delete arg1;
96623       if( argWidgetV )
96624       {
96625         // free string data
96626         for( int i=0; i < argWidgetC+1; i++)
96627         {
96628           delete [] argWidgetV[i];
96629         }
96630         delete [] argWidgetV;
96631       }
96632     } catch (std::out_of_range& e) {
96633       {
96634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96635       };
96636     } catch (std::exception& e) {
96637       {
96638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96639       };
96640     } catch (...) {
96641       {
96642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96643       };
96644     }
96645   }
96646 }
96647
96648
96649 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96650 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96651
96652 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96653 {
96654   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96655   return *widget;
96656 }
96657
96658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96659   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96660   std::string *arg2 = 0 ;
96661
96662   arg1 = (Dali::WidgetApplication *)jarg1;
96663   if (!jarg2) {
96664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96665     return ;
96666   }
96667   std::string arg2_str(*jarg2);
96668   arg2 = &arg2_str;
96669
96670   if(!_CSharpCreateWidgetFunction)
96671   {
96672     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96673   }
96674
96675   {
96676     try {
96677       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
96678     } catch (std::out_of_range& e) {
96679       {
96680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96681       };
96682     } catch (std::exception& e) {
96683       {
96684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96685       };
96686     } catch (...) {
96687       {
96688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96689       };
96690     }
96691   }
96692
96693   //Typemap argout in c++ file.
96694   //This will convert c++ string to c# string
96695   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
96696 }
96697
96698
96699 //for PixelBuffer and ImageLoading
96700
96701 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
96702     return (Dali::BaseHandle *)jarg1;
96703 }
96704
96705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
96706   void * jresult ;
96707   unsigned int arg1 ;
96708   unsigned int arg2 ;
96709   Dali::Pixel::Format arg3 ;
96710   Dali::Devel::PixelBuffer result;
96711
96712   arg1 = (unsigned int)jarg1;
96713   arg2 = (unsigned int)jarg2;
96714   arg3 = (Dali::Pixel::Format)jarg3;
96715   {
96716     try {
96717       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
96718     } catch (std::out_of_range& e) {
96719       {
96720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96721       };
96722     } catch (std::exception& e) {
96723       {
96724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96725       };
96726     } catch (...) {
96727       {
96728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96729       };
96730     }
96731   }
96732   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
96733   return jresult;
96734 }
96735
96736
96737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
96738   void * jresult ;
96739   Dali::Devel::PixelBuffer *result = 0 ;
96740
96741   {
96742     try {
96743       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
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 = (void *)result;
96759   return jresult;
96760 }
96761
96762
96763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
96764   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96765
96766   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96767   {
96768     try {
96769       delete arg1;
96770     } catch (std::out_of_range& e) {
96771       {
96772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96773       };
96774     } catch (std::exception& e) {
96775       {
96776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96777       };
96778     } catch (...) {
96779       {
96780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96781       };
96782     }
96783   }
96784 }
96785
96786
96787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
96788   void * jresult ;
96789   Dali::Devel::PixelBuffer *arg1 = 0 ;
96790   Dali::Devel::PixelBuffer *result = 0 ;
96791
96792   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96793   if (!arg1) {
96794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96795     return 0;
96796   }
96797   {
96798     try {
96799       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
96800     } catch (std::out_of_range& e) {
96801       {
96802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96803       };
96804     } catch (std::exception& e) {
96805       {
96806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96807       };
96808     } catch (...) {
96809       {
96810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96811       };
96812     }
96813   }
96814   jresult = (void *)result;
96815   return jresult;
96816 }
96817
96818
96819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
96820   void * jresult ;
96821   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96822   Dali::Devel::PixelBuffer *arg2 = 0 ;
96823   Dali::Devel::PixelBuffer *result = 0 ;
96824
96825   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96826   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
96827   if (!arg2) {
96828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96829     return 0;
96830   }
96831   {
96832     try {
96833       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
96834     } catch (std::out_of_range& e) {
96835       {
96836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96837       };
96838     } catch (std::exception& e) {
96839       {
96840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96841       };
96842     } catch (...) {
96843       {
96844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96845       };
96846     }
96847   }
96848   jresult = (void *)result;
96849   return jresult;
96850 }
96851
96852
96853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
96854   void * jresult ;
96855   Dali::Devel::PixelBuffer *arg1 = 0 ;
96856   Dali::PixelData result;
96857
96858   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96859   if (!arg1) {
96860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
96861     return 0;
96862   }
96863   {
96864     try {
96865       result = Dali::Devel::PixelBuffer::Convert(*arg1);
96866     } catch (std::out_of_range& e) {
96867       {
96868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96869       };
96870     } catch (std::exception& e) {
96871       {
96872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96873       };
96874     } catch (...) {
96875       {
96876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96877       };
96878     }
96879   }
96880   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96881   return jresult;
96882 }
96883
96884
96885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
96886   void * jresult ;
96887   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96888   Dali::PixelData result;
96889
96890   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96891   {
96892     try {
96893       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
96894     } catch (std::out_of_range& e) {
96895       {
96896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96897       };
96898     } catch (std::exception& e) {
96899       {
96900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96901       };
96902     } catch (...) {
96903       {
96904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96905       };
96906     }
96907   }
96908   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96909   return jresult;
96910 }
96911
96912
96913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
96914   void * jresult ;
96915   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96916   unsigned char *result = 0 ;
96917
96918   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96919   {
96920     try {
96921       result = (unsigned char *)(arg1)->GetBuffer();
96922     } catch (std::out_of_range& e) {
96923       {
96924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96925       };
96926     } catch (std::exception& e) {
96927       {
96928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96929       };
96930     } catch (...) {
96931       {
96932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96933       };
96934     }
96935   }
96936   jresult = (void *)result;
96937   return jresult;
96938 }
96939
96940
96941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
96942   unsigned int jresult ;
96943   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96944   unsigned int result;
96945
96946   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96947   {
96948     try {
96949       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
96950     } catch (std::out_of_range& e) {
96951       {
96952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96953       };
96954     } catch (std::exception& e) {
96955       {
96956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96957       };
96958     } catch (...) {
96959       {
96960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96961       };
96962     }
96963   }
96964   jresult = result;
96965   return jresult;
96966 }
96967
96968
96969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
96970   unsigned int jresult ;
96971   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96972   unsigned int result;
96973
96974   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96975   {
96976     try {
96977       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
96978     } catch (std::out_of_range& e) {
96979       {
96980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96981       };
96982     } catch (std::exception& e) {
96983       {
96984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96985       };
96986     } catch (...) {
96987       {
96988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96989       };
96990     }
96991   }
96992   jresult = result;
96993   return jresult;
96994 }
96995
96996
96997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
96998   int jresult ;
96999   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97000   Dali::Pixel::Format result;
97001
97002   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97003   {
97004     try {
97005       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
97006     } catch (std::out_of_range& e) {
97007       {
97008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97009       };
97010     } catch (std::exception& e) {
97011       {
97012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97013       };
97014     } catch (...) {
97015       {
97016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97017       };
97018     }
97019   }
97020   jresult = (int)result;
97021   return jresult;
97022 }
97023
97024
97025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
97026   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97027   Dali::Devel::PixelBuffer arg2 ;
97028   float arg3 ;
97029   bool arg4 ;
97030   Dali::Devel::PixelBuffer *argp2 ;
97031
97032   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97033   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97034   if (!argp2) {
97035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97036     return ;
97037   }
97038   arg2 = *argp2;
97039   arg3 = (float)jarg3;
97040   arg4 = jarg4 ? true : false;
97041   {
97042     try {
97043       (arg1)->ApplyMask(arg2,arg3,arg4);
97044     } catch (std::out_of_range& e) {
97045       {
97046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97047       };
97048     } catch (std::exception& e) {
97049       {
97050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97051       };
97052     } catch (...) {
97053       {
97054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97055       };
97056     }
97057   }
97058 }
97059
97060
97061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
97062   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97063   Dali::Devel::PixelBuffer arg2 ;
97064   float arg3 ;
97065   Dali::Devel::PixelBuffer *argp2 ;
97066
97067   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97068   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97069   if (!argp2) {
97070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97071     return ;
97072   }
97073   arg2 = *argp2;
97074   arg3 = (float)jarg3;
97075   {
97076     try {
97077       (arg1)->ApplyMask(arg2,arg3);
97078     } catch (std::out_of_range& e) {
97079       {
97080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97081       };
97082     } catch (std::exception& e) {
97083       {
97084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97085       };
97086     } catch (...) {
97087       {
97088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97089       };
97090     }
97091   }
97092 }
97093
97094
97095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
97096   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97097   Dali::Devel::PixelBuffer arg2 ;
97098   Dali::Devel::PixelBuffer *argp2 ;
97099
97100   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97101   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97102   if (!argp2) {
97103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97104     return ;
97105   }
97106   arg2 = *argp2;
97107   {
97108     try {
97109       (arg1)->ApplyMask(arg2);
97110     } catch (std::out_of_range& e) {
97111       {
97112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97113       };
97114     } catch (std::exception& e) {
97115       {
97116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97117       };
97118     } catch (...) {
97119       {
97120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97121       };
97122     }
97123   }
97124 }
97125
97126
97127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
97128   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97129   float arg2 ;
97130
97131   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97132   arg2 = (float)jarg2;
97133   {
97134     try {
97135       (arg1)->ApplyGaussianBlur(arg2);
97136     } catch (std::out_of_range& e) {
97137       {
97138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97139       };
97140     } catch (std::exception& e) {
97141       {
97142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97143       };
97144     } catch (...) {
97145       {
97146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97147       };
97148     }
97149   }
97150 }
97151
97152
97153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
97154   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97155   uint16_t arg2 ;
97156   uint16_t arg3 ;
97157   uint16_t arg4 ;
97158   uint16_t arg5 ;
97159
97160   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97161   arg2 = (uint16_t)jarg2;
97162   arg3 = (uint16_t)jarg3;
97163   arg4 = (uint16_t)jarg4;
97164   arg5 = (uint16_t)jarg5;
97165   {
97166     try {
97167       (arg1)->Crop(arg2,arg3,arg4,arg5);
97168     } catch (std::out_of_range& e) {
97169       {
97170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97171       };
97172     } catch (std::exception& e) {
97173       {
97174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97175       };
97176     } catch (...) {
97177       {
97178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97179       };
97180     }
97181   }
97182 }
97183
97184
97185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97186   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97187   uint16_t arg2 ;
97188   uint16_t arg3 ;
97189
97190   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97191   arg2 = (uint16_t)jarg2;
97192   arg3 = (uint16_t)jarg3;
97193   {
97194     try {
97195       (arg1)->Resize(arg2,arg3);
97196     } catch (std::out_of_range& e) {
97197       {
97198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97199       };
97200     } catch (std::exception& e) {
97201       {
97202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97203       };
97204     } catch (...) {
97205       {
97206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97207       };
97208     }
97209   }
97210 }
97211
97212 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97213   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97214   Dali::Degree * arg2 ;
97215
97216   bool result = false;
97217
97218   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97219   arg2 = (Dali::Degree *)jarg2;
97220   {
97221     try {
97222       result = (arg1)->Rotate(*arg2);
97223     } catch (std::out_of_range& e) {
97224       {
97225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97226       };
97227     } catch (std::exception& e) {
97228       {
97229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97230       };
97231     } catch (...) {
97232       {
97233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97234       };
97235     }
97236   }
97237   return result;
97238 }
97239
97240
97241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97242   void * jresult ;
97243   std::string *arg1 = 0 ;
97244   Dali::ImageDimensions arg2 ;
97245   Dali::FittingMode::Type arg3 ;
97246   Dali::SamplingMode::Type arg4 ;
97247   bool arg5 ;
97248   Dali::ImageDimensions *argp2 ;
97249   Dali::Devel::PixelBuffer result;
97250
97251   if (!jarg1) {
97252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97253     return 0;
97254   }
97255   std::string arg1_str(jarg1);
97256   arg1 = &arg1_str;
97257   argp2 = (Dali::ImageDimensions *)jarg2;
97258   if (!argp2) {
97259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97260     return 0;
97261   }
97262   arg2 = *argp2;
97263   arg3 = (Dali::FittingMode::Type)jarg3;
97264   arg4 = (Dali::SamplingMode::Type)jarg4;
97265   arg5 = jarg5 ? true : false;
97266   {
97267     try {
97268       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97269     } catch (std::out_of_range& e) {
97270       {
97271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97272       };
97273     } catch (std::exception& e) {
97274       {
97275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97276       };
97277     } catch (...) {
97278       {
97279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97280       };
97281     }
97282   }
97283   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97284
97285   return jresult;
97286 }
97287
97288
97289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97290   void * jresult ;
97291   std::string *arg1 = 0 ;
97292   Dali::ImageDimensions arg2 ;
97293   Dali::FittingMode::Type arg3 ;
97294   Dali::SamplingMode::Type arg4 ;
97295   Dali::ImageDimensions *argp2 ;
97296   Dali::Devel::PixelBuffer result;
97297
97298   if (!jarg1) {
97299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97300     return 0;
97301   }
97302   std::string arg1_str(jarg1);
97303   arg1 = &arg1_str;
97304   argp2 = (Dali::ImageDimensions *)jarg2;
97305   if (!argp2) {
97306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97307     return 0;
97308   }
97309   arg2 = *argp2;
97310   arg3 = (Dali::FittingMode::Type)jarg3;
97311   arg4 = (Dali::SamplingMode::Type)jarg4;
97312   {
97313     try {
97314       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97315     } catch (std::out_of_range& e) {
97316       {
97317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97318       };
97319     } catch (std::exception& e) {
97320       {
97321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97322       };
97323     } catch (...) {
97324       {
97325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97326       };
97327     }
97328   }
97329   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97330
97331   return jresult;
97332 }
97333
97334
97335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97336   void * jresult ;
97337   std::string *arg1 = 0 ;
97338   Dali::ImageDimensions arg2 ;
97339   Dali::FittingMode::Type arg3 ;
97340   Dali::ImageDimensions *argp2 ;
97341   Dali::Devel::PixelBuffer result;
97342
97343   if (!jarg1) {
97344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97345     return 0;
97346   }
97347   std::string arg1_str(jarg1);
97348   arg1 = &arg1_str;
97349   argp2 = (Dali::ImageDimensions *)jarg2;
97350   if (!argp2) {
97351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97352     return 0;
97353   }
97354   arg2 = *argp2;
97355   arg3 = (Dali::FittingMode::Type)jarg3;
97356   {
97357     try {
97358       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97359     } catch (std::out_of_range& e) {
97360       {
97361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97362       };
97363     } catch (std::exception& e) {
97364       {
97365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97366       };
97367     } catch (...) {
97368       {
97369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97370       };
97371     }
97372   }
97373   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97374
97375   return jresult;
97376 }
97377
97378
97379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97380   void * jresult ;
97381   std::string *arg1 = 0 ;
97382   Dali::ImageDimensions arg2 ;
97383   Dali::ImageDimensions *argp2 ;
97384   Dali::Devel::PixelBuffer result;
97385
97386   if (!jarg1) {
97387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97388     return 0;
97389   }
97390   std::string arg1_str(jarg1);
97391   arg1 = &arg1_str;
97392   argp2 = (Dali::ImageDimensions *)jarg2;
97393   if (!argp2) {
97394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97395     return 0;
97396   }
97397   arg2 = *argp2;
97398   {
97399     try {
97400       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97401     } catch (std::out_of_range& e) {
97402       {
97403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97404       };
97405     } catch (std::exception& e) {
97406       {
97407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97408       };
97409     } catch (...) {
97410       {
97411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97412       };
97413     }
97414   }
97415   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97416
97417   return jresult;
97418 }
97419
97420
97421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
97422   void * jresult ;
97423   std::string *arg1 = 0 ;
97424   Dali::Devel::PixelBuffer result;
97425
97426   if (!jarg1) {
97427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97428     return 0;
97429   }
97430   std::string arg1_str(jarg1);
97431   arg1 = &arg1_str;
97432   {
97433     try {
97434       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97435     } catch (std::out_of_range& e) {
97436       {
97437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97438       };
97439     } catch (std::exception& e) {
97440       {
97441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97442       };
97443     } catch (...) {
97444       {
97445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97446       };
97447     }
97448   }
97449   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97450
97451   return jresult;
97452 }
97453
97454
97455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97456   void * jresult ;
97457   std::string *arg1 = 0 ;
97458   Dali::ImageDimensions arg2 ;
97459   Dali::FittingMode::Type arg3 ;
97460   Dali::SamplingMode::Type arg4 ;
97461   bool arg5 ;
97462   Dali::ImageDimensions *argp2 ;
97463   Dali::ImageDimensions result;
97464
97465   if (!jarg1) {
97466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97467     return 0;
97468   }
97469   std::string arg1_str(jarg1);
97470   arg1 = &arg1_str;
97471   argp2 = (Dali::ImageDimensions *)jarg2;
97472   if (!argp2) {
97473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97474     return 0;
97475   }
97476   arg2 = *argp2;
97477   arg3 = (Dali::FittingMode::Type)jarg3;
97478   arg4 = (Dali::SamplingMode::Type)jarg4;
97479   arg5 = jarg5 ? true : false;
97480   {
97481     try {
97482       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97483     } catch (std::out_of_range& e) {
97484       {
97485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97486       };
97487     } catch (std::exception& e) {
97488       {
97489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97490       };
97491     } catch (...) {
97492       {
97493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97494       };
97495     }
97496   }
97497   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97498
97499   return jresult;
97500 }
97501
97502
97503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97504   void * jresult ;
97505   std::string *arg1 = 0 ;
97506   Dali::ImageDimensions arg2 ;
97507   Dali::FittingMode::Type arg3 ;
97508   Dali::SamplingMode::Type arg4 ;
97509   Dali::ImageDimensions *argp2 ;
97510   Dali::ImageDimensions result;
97511
97512   if (!jarg1) {
97513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97514     return 0;
97515   }
97516   std::string arg1_str(jarg1);
97517   arg1 = &arg1_str;
97518   argp2 = (Dali::ImageDimensions *)jarg2;
97519   if (!argp2) {
97520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97521     return 0;
97522   }
97523   arg2 = *argp2;
97524   arg3 = (Dali::FittingMode::Type)jarg3;
97525   arg4 = (Dali::SamplingMode::Type)jarg4;
97526   {
97527     try {
97528       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97529     } catch (std::out_of_range& e) {
97530       {
97531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97532       };
97533     } catch (std::exception& e) {
97534       {
97535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97536       };
97537     } catch (...) {
97538       {
97539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97540       };
97541     }
97542   }
97543   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97544
97545   return jresult;
97546 }
97547
97548
97549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97550   void * jresult ;
97551   std::string *arg1 = 0 ;
97552   Dali::ImageDimensions arg2 ;
97553   Dali::FittingMode::Type arg3 ;
97554   Dali::ImageDimensions *argp2 ;
97555   Dali::ImageDimensions result;
97556
97557   if (!jarg1) {
97558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97559     return 0;
97560   }
97561   std::string arg1_str(jarg1);
97562   arg1 = &arg1_str;
97563   argp2 = (Dali::ImageDimensions *)jarg2;
97564   if (!argp2) {
97565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97566     return 0;
97567   }
97568   arg2 = *argp2;
97569   arg3 = (Dali::FittingMode::Type)jarg3;
97570   {
97571     try {
97572       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97573     } catch (std::out_of_range& e) {
97574       {
97575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97576       };
97577     } catch (std::exception& e) {
97578       {
97579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97580       };
97581     } catch (...) {
97582       {
97583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97584       };
97585     }
97586   }
97587   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97588
97589   return jresult;
97590 }
97591
97592
97593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97594   void * jresult ;
97595   std::string *arg1 = 0 ;
97596   Dali::ImageDimensions arg2 ;
97597   Dali::ImageDimensions *argp2 ;
97598   Dali::ImageDimensions result;
97599
97600   if (!jarg1) {
97601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97602     return 0;
97603   }
97604   std::string arg1_str(jarg1);
97605   arg1 = &arg1_str;
97606   argp2 = (Dali::ImageDimensions *)jarg2;
97607   if (!argp2) {
97608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97609     return 0;
97610   }
97611   arg2 = *argp2;
97612   {
97613     try {
97614       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
97615     } catch (std::out_of_range& e) {
97616       {
97617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97618       };
97619     } catch (std::exception& e) {
97620       {
97621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97622       };
97623     } catch (...) {
97624       {
97625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97626       };
97627     }
97628   }
97629   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97630
97631   return jresult;
97632 }
97633
97634
97635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97636   void * jresult ;
97637   std::string *arg1 = 0 ;
97638   Dali::ImageDimensions result;
97639
97640   if (!jarg1) {
97641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97642     return 0;
97643   }
97644   std::string arg1_str(jarg1);
97645   arg1 = &arg1_str;
97646   {
97647     try {
97648       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97649     } catch (std::out_of_range& e) {
97650       {
97651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97652       };
97653     } catch (std::exception& e) {
97654       {
97655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97656       };
97657     } catch (...) {
97658       {
97659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97660       };
97661     }
97662   }
97663   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97664
97665   return jresult;
97666 }
97667
97668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97669   void * jresult ;
97670   std::string *arg1 = 0 ;
97671   Dali::ImageDimensions result;
97672
97673   if (!jarg1) {
97674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97675     return 0;
97676   }
97677   std::string arg1_str(jarg1);
97678   arg1 = &arg1_str;
97679   {
97680     try {
97681       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
97682     } catch (std::out_of_range& e) {
97683       {
97684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97685       };
97686     } catch (std::exception& e) {
97687       {
97688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97689       };
97690     } catch (...) {
97691       {
97692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97693       };
97694     }
97695   }
97696   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97697
97698   return jresult;
97699 }
97700
97701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97702   void * jresult ;
97703   std::string *arg1 = 0 ;
97704   Dali::ImageDimensions arg2 ;
97705   Dali::FittingMode::Type arg3 ;
97706   Dali::SamplingMode::Type arg4 ;
97707   bool arg5 ;
97708   Dali::ImageDimensions *argp2 ;
97709   Dali::Devel::PixelBuffer result;
97710
97711   if (!jarg1) {
97712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97713     return 0;
97714   }
97715   std::string arg1_str(jarg1);
97716   arg1 = &arg1_str;
97717   argp2 = (Dali::ImageDimensions *)jarg2;
97718   if (!argp2) {
97719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97720     return 0;
97721   }
97722   arg2 = *argp2;
97723   arg3 = (Dali::FittingMode::Type)jarg3;
97724   arg4 = (Dali::SamplingMode::Type)jarg4;
97725   arg5 = jarg5 ? true : false;
97726   {
97727     try {
97728       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97729     } catch (std::out_of_range& e) {
97730       {
97731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97732       };
97733     } catch (std::exception& e) {
97734       {
97735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97736       };
97737     } catch (...) {
97738       {
97739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97740       };
97741     }
97742   }
97743   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97744
97745   return jresult;
97746 }
97747
97748
97749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97750   void * jresult ;
97751   std::string *arg1 = 0 ;
97752   Dali::ImageDimensions arg2 ;
97753   Dali::FittingMode::Type arg3 ;
97754   Dali::SamplingMode::Type arg4 ;
97755   Dali::ImageDimensions *argp2 ;
97756   Dali::Devel::PixelBuffer result;
97757
97758   if (!jarg1) {
97759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97760     return 0;
97761   }
97762   std::string arg1_str(jarg1);
97763   arg1 = &arg1_str;
97764   argp2 = (Dali::ImageDimensions *)jarg2;
97765   if (!argp2) {
97766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97767     return 0;
97768   }
97769   arg2 = *argp2;
97770   arg3 = (Dali::FittingMode::Type)jarg3;
97771   arg4 = (Dali::SamplingMode::Type)jarg4;
97772   {
97773     try {
97774       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
97775     } catch (std::out_of_range& e) {
97776       {
97777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97778       };
97779     } catch (std::exception& e) {
97780       {
97781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97782       };
97783     } catch (...) {
97784       {
97785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97786       };
97787     }
97788   }
97789   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97790
97791   return jresult;
97792 }
97793
97794
97795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97796   void * jresult ;
97797   std::string *arg1 = 0 ;
97798   Dali::ImageDimensions arg2 ;
97799   Dali::FittingMode::Type arg3 ;
97800   Dali::ImageDimensions *argp2 ;
97801   Dali::Devel::PixelBuffer result;
97802
97803   if (!jarg1) {
97804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97805     return 0;
97806   }
97807   std::string arg1_str(jarg1);
97808   arg1 = &arg1_str;
97809   argp2 = (Dali::ImageDimensions *)jarg2;
97810   if (!argp2) {
97811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97812     return 0;
97813   }
97814   arg2 = *argp2;
97815   arg3 = (Dali::FittingMode::Type)jarg3;
97816   {
97817     try {
97818       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
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 (...) {
97828       {
97829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97830       };
97831     }
97832   }
97833   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97834
97835   return jresult;
97836 }
97837
97838
97839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
97840   void * jresult ;
97841   std::string *arg1 = 0 ;
97842   Dali::ImageDimensions arg2 ;
97843   Dali::ImageDimensions *argp2 ;
97844   Dali::Devel::PixelBuffer result;
97845
97846   if (!jarg1) {
97847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97848     return 0;
97849   }
97850   std::string arg1_str(jarg1);
97851   arg1 = &arg1_str;
97852   argp2 = (Dali::ImageDimensions *)jarg2;
97853   if (!argp2) {
97854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97855     return 0;
97856   }
97857   arg2 = *argp2;
97858   {
97859     try {
97860       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
97861     } catch (std::out_of_range& e) {
97862       {
97863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97864       };
97865     } catch (std::exception& e) {
97866       {
97867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97868       };
97869     } catch (...) {
97870       {
97871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97872       };
97873     }
97874   }
97875   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97876
97877   return jresult;
97878 }
97879
97880
97881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
97882   void * jresult ;
97883   std::string *arg1 = 0 ;
97884   Dali::Devel::PixelBuffer result;
97885
97886   if (!jarg1) {
97887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97888     return 0;
97889   }
97890   std::string arg1_str(jarg1);
97891   arg1 = &arg1_str;
97892   {
97893     try {
97894       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
97895     } catch (std::out_of_range& e) {
97896       {
97897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97898       };
97899     } catch (std::exception& e) {
97900       {
97901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97902       };
97903     } catch (...) {
97904       {
97905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97906       };
97907     }
97908   }
97909   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97910
97911   return jresult;
97912 }
97913
97914
97915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
97916   void * jresult ;
97917   Dali::Toolkit::WebView result;
97918
97919   {
97920     try {
97921       result = Dali::Toolkit::WebView::New();
97922     } catch (std::out_of_range& e) {
97923       {
97924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97925       };
97926     } catch (std::exception& e) {
97927       {
97928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97929       };
97930     } catch (Dali::DaliException e) {
97931       {
97932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97933       };
97934     } catch (...) {
97935       {
97936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97937       };
97938     }
97939   }
97940   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97941   return jresult;
97942 }
97943
97944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
97945   void * jresult ;
97946   Dali::Toolkit::WebView result;
97947
97948   std::string *arg1;
97949   std::string *arg2;
97950
97951   if (!jarg1) {
97952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
97953     return 0;
97954   }
97955   if (!jarg2) {
97956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
97957     return 0;
97958   }
97959
97960   std::string jarg1_str = std::string(jarg1);
97961   std::string jarg2_str = std::string(jarg2);
97962
97963   arg1 = &jarg1_str;
97964   arg2 = &jarg2_str;
97965
97966   {
97967     try {
97968       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
97969     } catch (std::out_of_range& e) {
97970       {
97971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97972       };
97973     } catch (std::exception& e) {
97974       {
97975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97976       };
97977     } catch (Dali::DaliException e) {
97978       {
97979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97980       };
97981     } catch (...) {
97982       {
97983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97984       };
97985     }
97986   }
97987   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97988   return jresult;
97989 }
97990
97991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
97992   void * jresult ;
97993   Dali::Toolkit::WebView *arg1 = 0 ;
97994   Dali::Toolkit::WebView *result = 0 ;
97995
97996   arg1 = (Dali::Toolkit::WebView *)jarg1;
97997   if (!arg1) {
97998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
97999     return 0;
98000   }
98001   {
98002     try {
98003       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
98004     } catch (std::out_of_range& e) {
98005       {
98006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98007       };
98008     } catch (std::exception& e) {
98009       {
98010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98011       };
98012     } catch (Dali::DaliException e) {
98013       {
98014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98015       };
98016     } catch (...) {
98017       {
98018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98019       };
98020     }
98021   }
98022   jresult = (void *)result;
98023   return jresult;
98024 }
98025
98026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
98027   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98028   arg1 = (Dali::Toolkit::WebView *)jarg1;
98029   {
98030     try {
98031       delete arg1;
98032     } catch (std::out_of_range& e) {
98033       {
98034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98035       };
98036     } catch (std::exception& e) {
98037       {
98038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98039       };
98040     } catch (Dali::DaliException e) {
98041       {
98042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98043       };
98044     } catch (...) {
98045       {
98046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98047       };
98048     }
98049   }
98050 }
98051
98052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
98053   void * jresult ;
98054   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98055   Dali::Toolkit::WebView *arg2 = 0 ;
98056   Dali::Toolkit::WebView *result = 0 ;
98057
98058   arg1 = (Dali::Toolkit::WebView *)jarg1;
98059   arg2 = (Dali::Toolkit::WebView *)jarg2;
98060   if (!arg2) {
98061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98062     return 0;
98063   }
98064   {
98065     try {
98066       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
98067     } catch (std::out_of_range& e) {
98068       {
98069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98070       };
98071     } catch (std::exception& e) {
98072       {
98073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98074       };
98075     } catch (Dali::DaliException e) {
98076       {
98077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98078       };
98079     } catch (...) {
98080       {
98081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98082       };
98083     }
98084   }
98085   jresult = (void *)result;
98086   return jresult;
98087 }
98088
98089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
98090   void * jresult ;
98091   Dali::BaseHandle arg1 ;
98092   Dali::BaseHandle *argp1 ;
98093   Dali::Toolkit::WebView result;
98094
98095   argp1 = (Dali::BaseHandle *)jarg1;
98096   if (!argp1) {
98097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
98098     return 0;
98099   }
98100   arg1 = *argp1;
98101   {
98102     try {
98103       result = Dali::Toolkit::WebView::DownCast(arg1);
98104     } catch (std::out_of_range& e) {
98105       {
98106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98107       };
98108     } catch (std::exception& e) {
98109       {
98110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98111       };
98112     } catch (Dali::DaliException e) {
98113       {
98114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98115       };
98116     } catch (...) {
98117       {
98118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98119       };
98120     }
98121   }
98122   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98123   return jresult;
98124 }
98125
98126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
98127   return (int) Dali::Toolkit::WebView::Property::URL;
98128 }
98129
98130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
98131   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
98132 }
98133
98134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
98135   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
98136 }
98137
98138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
98139   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
98140 }
98141
98142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
98143   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
98144 }
98145
98146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
98147   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
98148 }
98149
98150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
98151   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
98152 }
98153
98154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
98155   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
98156 }
98157
98158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
98159   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98160   std::string *arg2;
98161
98162   arg1 = (Dali::Toolkit::WebView *)jarg1;
98163
98164   if (!jarg2) {
98165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98166     return;
98167   }
98168
98169   std::string jarg2str = std::string(jarg2);
98170   arg2 = &jarg2str;
98171   {
98172     try {
98173       (arg1)->LoadUrl((std::string const &)*arg2);
98174     } catch (std::out_of_range& e) {
98175       {
98176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98177       };
98178     } catch (std::exception& e) {
98179       {
98180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98181       };
98182     } catch (Dali::DaliException e) {
98183       {
98184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98185       };
98186     } catch (...) {
98187       {
98188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98189       };
98190     }
98191   }
98192 }
98193
98194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
98195   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98196   std::string *arg2;
98197
98198   arg1 = (Dali::Toolkit::WebView *)jarg1;
98199   if (!jarg2) {
98200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98201     return;
98202   }
98203   std::string jarg2str = std::string(jarg2);
98204   arg2 = &jarg2str;
98205   {
98206     try {
98207       (arg1)->LoadHTMLString((std::string const &)*arg2);
98208     } catch (std::out_of_range& e) {
98209       {
98210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98211       };
98212     } catch (std::exception& e) {
98213       {
98214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98215       };
98216     } catch (Dali::DaliException e) {
98217       {
98218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98219       };
98220     } catch (...) {
98221       {
98222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98223       };
98224     }
98225   }
98226 }
98227
98228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98229   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98230
98231   arg1 = (Dali::Toolkit::WebView *)jarg1;
98232   {
98233     try {
98234       (arg1)->Reload();
98235     } catch (std::out_of_range& e) {
98236       {
98237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98238       };
98239     } catch (std::exception& e) {
98240       {
98241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98242       };
98243     } catch (Dali::DaliException e) {
98244       {
98245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98246       };
98247     } catch (...) {
98248       {
98249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98250       };
98251     }
98252   }
98253 }
98254
98255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98256   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98257
98258   arg1 = (Dali::Toolkit::WebView *)jarg1;
98259   {
98260     try {
98261       (arg1)->StopLoading();
98262     } catch (std::out_of_range& e) {
98263       {
98264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98265       };
98266     } catch (std::exception& e) {
98267       {
98268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98269       };
98270     } catch (Dali::DaliException e) {
98271       {
98272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98273       };
98274     } catch (...) {
98275       {
98276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98277       };
98278     }
98279   }
98280 }
98281
98282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98283   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98284
98285   arg1 = (Dali::Toolkit::WebView *)jarg1;
98286   {
98287     try {
98288       (arg1)->Suspend();
98289     } catch (std::out_of_range& e) {
98290       {
98291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98292       };
98293     } catch (std::exception& e) {
98294       {
98295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98296       };
98297     } catch (Dali::DaliException e) {
98298       {
98299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98300       };
98301     } catch (...) {
98302       {
98303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98304       };
98305     }
98306   }
98307 }
98308
98309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98310   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98311
98312   arg1 = (Dali::Toolkit::WebView *)jarg1;
98313   {
98314     try {
98315       (arg1)->Resume();
98316     } catch (std::out_of_range& e) {
98317       {
98318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98319       };
98320     } catch (std::exception& e) {
98321       {
98322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98323       };
98324     } catch (Dali::DaliException e) {
98325       {
98326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98327       };
98328     } catch (...) {
98329       {
98330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98331       };
98332     }
98333   }
98334 }
98335
98336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98337   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98338
98339   arg1 = (Dali::Toolkit::WebView *)jarg1;
98340   {
98341     try {
98342       (arg1)->GoBack();
98343     } catch (std::out_of_range& e) {
98344       {
98345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98346       };
98347     } catch (std::exception& e) {
98348       {
98349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98350       };
98351     } catch (Dali::DaliException e) {
98352       {
98353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98354       };
98355     } catch (...) {
98356       {
98357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98358       };
98359     }
98360   }
98361 }
98362
98363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98364   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98365
98366   arg1 = (Dali::Toolkit::WebView *)jarg1;
98367   {
98368     try {
98369       (arg1)->GoForward();
98370     } catch (std::out_of_range& e) {
98371       {
98372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98373       };
98374     } catch (std::exception& e) {
98375       {
98376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98377       };
98378     } catch (Dali::DaliException e) {
98379       {
98380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98381       };
98382     } catch (...) {
98383       {
98384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98385       };
98386     }
98387   }
98388 }
98389
98390 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98391   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98392   bool ret;
98393
98394   arg1 = (Dali::Toolkit::WebView *)jarg1;
98395   {
98396     try {
98397       ret = (arg1)->CanGoBack();
98398     } catch (std::out_of_range& e) {
98399       {
98400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98401       };
98402     } catch (std::exception& e) {
98403       {
98404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98405       };
98406     } catch (Dali::DaliException e) {
98407       {
98408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98409       };
98410     } catch (...) {
98411       {
98412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98413       };
98414     }
98415   }
98416   return ret;
98417 }
98418
98419 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98420   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98421   bool ret;
98422
98423   arg1 = (Dali::Toolkit::WebView *)jarg1;
98424   {
98425     try {
98426       ret = (arg1)->CanGoForward();
98427     } catch (std::out_of_range& e) {
98428       {
98429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98430       };
98431     } catch (std::exception& e) {
98432       {
98433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98434       };
98435     } catch (Dali::DaliException e) {
98436       {
98437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98438       };
98439     } catch (...) {
98440       {
98441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98442       };
98443     }
98444   }
98445   return ret;
98446 }
98447
98448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98449   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98450   std::string *arg2;
98451
98452   arg1 = (Dali::Toolkit::WebView *)jarg1;
98453   if (!jarg2) {
98454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98455     return;
98456   }
98457   std::string jarg2_str = std::string(jarg2);
98458   arg2 = &jarg2_str;
98459
98460   {
98461     try {
98462       if (jarg3) {
98463         void (*handler)(char*) = (void (*)(char*)) jarg3;
98464         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98465           handler(SWIG_csharp_string_callback(result.c_str()));
98466         });
98467       } else {
98468         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98469       }
98470     } catch (std::out_of_range& e) {
98471       {
98472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98473       };
98474     } catch (std::exception& e) {
98475       {
98476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98477       };
98478     } catch (Dali::DaliException e) {
98479       {
98480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98481       };
98482     } catch (...) {
98483       {
98484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98485       };
98486     }
98487   }
98488 }
98489
98490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98491 {
98492   if (!jarg2) {
98493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98494     return;
98495   }
98496
98497   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98498   std::string exposedObjectName = jarg2;
98499   void (*handler)(char*) = (void (*)(char*)) jarg3;
98500
98501   {
98502     try {
98503       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98504         handler(SWIG_csharp_string_callback(message.c_str()));
98505       });
98506     } catch (std::out_of_range& e) {
98507       {
98508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98509       };
98510     } catch (std::exception& e) {
98511       {
98512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98513       };
98514     } catch (Dali::DaliException e) {
98515       {
98516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98517       };
98518     } catch (...) {
98519       {
98520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98521       };
98522     }
98523   }
98524 }
98525
98526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98527   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98528
98529   arg1 = (Dali::Toolkit::WebView *)jarg1;
98530   {
98531     try {
98532       (arg1)->ClearHistory();
98533     } catch (std::out_of_range& e) {
98534       {
98535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98536       };
98537     } catch (std::exception& e) {
98538       {
98539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98540       };
98541     } catch (Dali::DaliException e) {
98542       {
98543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98544       };
98545     } catch (...) {
98546       {
98547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98548       };
98549     }
98550   }
98551 }
98552
98553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98554   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98555
98556   arg1 = (Dali::Toolkit::WebView *)jarg1;
98557   {
98558     try {
98559       (arg1)->ClearCache();
98560     } catch (std::out_of_range& e) {
98561       {
98562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98563       };
98564     } catch (std::exception& e) {
98565       {
98566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98567       };
98568     } catch (Dali::DaliException e) {
98569       {
98570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98571       };
98572     } catch (...) {
98573       {
98574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98575       };
98576     }
98577   }
98578 }
98579
98580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98581   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98582
98583   arg1 = (Dali::Toolkit::WebView *)jarg1;
98584   {
98585     try {
98586       (arg1)->ClearCookies();
98587     } catch (std::out_of_range& e) {
98588       {
98589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98590       };
98591     } catch (std::exception& e) {
98592       {
98593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98594       };
98595     } catch (Dali::DaliException e) {
98596       {
98597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98598       };
98599     } catch (...) {
98600       {
98601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98602       };
98603     }
98604   }
98605 }
98606
98607 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98608     return (Dali::Toolkit::Control *)jarg1;
98609 }
98610
98611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98612   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98613   SignalConverter::WebViewPageLoadSignal* result = NULL;
98614   {
98615     try {
98616       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98617     } catch (std::out_of_range& e) {
98618       {
98619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98620       };
98621     } catch (std::exception& e) {
98622       {
98623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98624       };
98625     } catch (Dali::DaliException e) {
98626       {
98627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98628       };
98629     } catch (...) {
98630       {
98631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98632       };
98633     }
98634   }
98635   return (void*) result;
98636 }
98637
98638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98639   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98640   SignalConverter::WebViewPageLoadSignal* result = NULL;
98641   {
98642     try {
98643       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98644     } catch (std::out_of_range& e) {
98645       {
98646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98647       };
98648     } catch (std::exception& e) {
98649       {
98650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98651       };
98652     } catch (Dali::DaliException e) {
98653       {
98654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98655       };
98656     } catch (...) {
98657       {
98658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98659       };
98660     }
98661   }
98662   return (void*) result;
98663 }
98664
98665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98666 {
98667   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98668   {
98669     try {
98670       delete object;
98671     } catch (std::out_of_range& e) {
98672       {
98673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98674       };
98675     } catch (std::exception& e) {
98676       {
98677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98678       };
98679     } catch (Dali::DaliException e) {
98680       {
98681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98682       };
98683     } catch (...) {
98684       {
98685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98686       };
98687     }
98688   }
98689 }
98690
98691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
98692 {
98693   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98694   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98695   {
98696     try {
98697       proxy->Connect(callback);
98698     } catch (std::out_of_range& e) {
98699       {
98700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98701       };
98702     } catch (std::exception& e) {
98703       {
98704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98705       };
98706     } catch (Dali::DaliException e) {
98707       {
98708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98709       };
98710     } catch (...) {
98711       {
98712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98713       };
98714     }
98715   }
98716 }
98717
98718
98719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
98720   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98721   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98722   {
98723     try {
98724       proxy->Disconnect(callback);
98725     } catch (std::out_of_range& e) {
98726       {
98727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98728       };
98729     } catch (std::exception& e) {
98730       {
98731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98732       };
98733     } catch (Dali::DaliException e) {
98734       {
98735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98736       };
98737     } catch (...) {
98738       {
98739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98740       };
98741     }
98742   }
98743 }
98744
98745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
98746   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98747   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
98748   {
98749     try {
98750       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
98751     } catch (std::out_of_range& e) {
98752       {
98753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98754       };
98755     } catch (std::exception& e) {
98756       {
98757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98758       };
98759     } catch (Dali::DaliException e) {
98760       {
98761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98762       };
98763     } catch (...) {
98764       {
98765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98766       };
98767     }
98768   }
98769   return (void*) result;
98770 }
98771
98772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
98773 {
98774   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98775   {
98776     try {
98777       delete object;
98778     } catch (std::out_of_range& e) {
98779       {
98780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98781       };
98782     } catch (std::exception& e) {
98783       {
98784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98785       };
98786     } catch (Dali::DaliException e) {
98787       {
98788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98789       };
98790     } catch (...) {
98791       {
98792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98793       };
98794     }
98795   }
98796 }
98797
98798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
98799 {
98800   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98801   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98802   {
98803     try {
98804       proxy->Connect(callback);
98805     } catch (std::out_of_range& e) {
98806       {
98807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98808       };
98809     } catch (std::exception& e) {
98810       {
98811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98812       };
98813     } catch (Dali::DaliException e) {
98814       {
98815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98816       };
98817     } catch (...) {
98818       {
98819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98820       };
98821     }
98822   }
98823 }
98824
98825
98826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
98827   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98828   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98829   {
98830     try {
98831       proxy->Disconnect(callback);
98832     } catch (std::out_of_range& e) {
98833       {
98834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98835       };
98836     } catch (std::exception& e) {
98837       {
98838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98839       };
98840     } catch (Dali::DaliException e) {
98841       {
98842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98843       };
98844     } catch (...) {
98845       {
98846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98847       };
98848     }
98849   }
98850 }
98851
98852 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
98853   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
98854   char * jresult = SWIG_csharp_string_callback((const char *)result);
98855   return jresult;
98856 }
98857
98858 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
98859   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
98860   return result;
98861 }
98862
98863
98864 struct NativeImageSourcePtrHandle
98865 {
98866   NativeImageSourcePtr Ptr;
98867 };
98868
98869 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
98870 {
98871   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98872   return (NativeImageInterface*)(arg1);
98873 }
98874
98875 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
98876 {
98877   void* jresult;
98878   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
98879   {
98880     try {
98881       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
98882     }
98883     catch (std::out_of_range & e) {
98884       {
98885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98886       };
98887     }
98888     catch (std::exception & e) {
98889       {
98890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98891       };
98892     }
98893     catch (Dali::DaliException e) {
98894       {
98895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98896       };
98897     }
98898     catch (...) {
98899       {
98900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98901       };
98902     }
98903   }
98904   jresult = (void *)handle;
98905   return jresult;
98906 }
98907
98908 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
98909 {
98910   void* jresult;
98911   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
98912   jresult = (void*)( handle->Ptr.Get() );
98913   return jresult;
98914 }
98915
98916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
98917   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
98918   {
98919     try {
98920       delete arg1;
98921     }
98922     catch (std::out_of_range & e) {
98923       {
98924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
98925       };
98926     }
98927     catch (std::exception & e) {
98928       {
98929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
98930       };
98931     }
98932     catch (Dali::DaliException e) {
98933       {
98934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
98935       };
98936     }
98937     catch (...) {
98938       {
98939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
98940       };
98941     }
98942   }
98943 }
98944
98945 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
98946 {
98947   void* jresult;
98948   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98949   uint16_t* arg2 = (uint16_t*)(jarg2);
98950   uint16_t* arg3 = (uint16_t*)(jarg3);
98951   uint16_t* arg4 = (uint16_t*)(jarg4);
98952   {
98953     try {
98954       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
98955     }
98956     catch (std::out_of_range & e) {
98957       {
98958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98959       };
98960     }
98961     catch (std::exception & e) {
98962       {
98963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98964       };
98965     }
98966     catch (Dali::DaliException e) {
98967       {
98968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98969       };
98970     }
98971     catch (...) {
98972       {
98973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98974       };
98975     }
98976   }
98977   return jresult;
98978 }
98979
98980 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
98981 {
98982   bool jresult;
98983   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98984
98985   {
98986     try {
98987       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
98988     }
98989     catch (std::out_of_range & e) {
98990       {
98991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98992       };
98993     }
98994     catch (std::exception & e) {
98995       {
98996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98997       };
98998     }
98999     catch (Dali::DaliException e) {
99000       {
99001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99002       };
99003     }
99004     catch (...) {
99005       {
99006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99007       };
99008     }
99009   }
99010   return jresult;
99011 }
99012
99013
99014 #ifdef __cplusplus
99015 }
99016 #endif